feat: extend agent-driven map workbench

app/api/agent-locate/route.ts

@@ -1,12 +1,13 @@
 import { NextResponse } from "next/server";
-import { MAP_URL } from "@/lib/config";
-const TYPES = { junction: "drainage:geo_junctions", conduit: "drainage:geo_conduits", pipe: "drainage:geo_conduits", orifice: "drainage:geo_orifices", outfall: "drainage:geo_outfalls", pump: "drainage:geo_pumps" } as const;
+import { GEOSERVER_WORKSPACE, MAP_URL } from "@/lib/config";
+const TYPES = { junction: "geo_junctions", conduit: "geo_conduits", pipe: "geo_conduits", orifice: "geo_orifices", outfall: "geo_outfalls", pump: "geo_pumps" } as const;
 export async function POST(request: Request) {
   const body = await request.json().catch(() => null) as { ids?: unknown; featureType?: unknown } | null;
   if (!body || !Array.isArray(body.ids) || body.ids.length < 1 || body.ids.length > 100 || !body.ids.every((id) => typeof id === "string" && id.trim())) return NextResponse.json({ code: "INVALID_REQUEST" }, { status: 400 });
   if (typeof body.featureType !== "string" || !(body.featureType in TYPES)) return NextResponse.json({ code: "UNSUPPORTED_FEATURE_TYPE" }, { status: 422 });
   const ids = body.ids.map((id) => String(id).trim()); const cql = `id IN (${ids.map((id) => `'${id.replaceAll("'", "''")}'`).join(",")})`;
-  const url = new URL(`${MAP_URL}/drainage/ows`); url.search = new URLSearchParams({ service: "WFS", version: "2.0.0", request: "GetFeature", typeNames: TYPES[body.featureType as keyof typeof TYPES], outputFormat: "application/json", srsName: "EPSG:4326", count: "100", cql_filter: cql }).toString();
+  const typeName = `${GEOSERVER_WORKSPACE}:${TYPES[body.featureType as keyof typeof TYPES]}`;
+  const url = new URL(`${MAP_URL}/${GEOSERVER_WORKSPACE}/ows`); url.search = new URLSearchParams({ service: "WFS", version: "2.0.0", request: "GetFeature", typeNames: typeName, outputFormat: "application/json", srsName: "EPSG:4326", count: "100", cql_filter: cql }).toString();
   try { const response = await fetch(url, { signal: AbortSignal.timeout(8_000), cache: "no-store" }); const data = await response.json(); if (!response.ok || !data || data.type !== "FeatureCollection" || !Array.isArray(data.features)) throw new Error(); return NextResponse.json({ type: "FeatureCollection", features: data.features.slice(0, 100) }); }
   catch { return NextResponse.json({ code: "WFS_UNAVAILABLE" }, { status: 502 }); }
 }

app/api/map-features/route.ts

@@ -0,0 +1,30 @@
+import { NextResponse } from "next/server";
+import {
+  MAX_CONDUIT_FEATURES,
+  MAX_MAP_FEATURE_IDS,
+  createMapFeatureWfsUrl,
+  normalizeMapFeatureCollection,
+  parseMapFeatureQuery
+} from "@/features/workbench/map/map-feature-query";
+
+export async function POST(request: Request) {
+  const parsed = parseMapFeatureQuery(await request.json().catch(() => null));
+  if (!parsed.ok) {
+    return NextResponse.json({ code: parsed.code }, { status: parsed.status });
+  }
+
+  try {
+    const response = await fetch(createMapFeatureWfsUrl(parsed.value), {
+      cache: "no-store",
+      signal: AbortSignal.timeout(8_000)
+    });
+    const collection = normalizeMapFeatureCollection(
+      await response.json(),
+      parsed.value.featureIds ? MAX_MAP_FEATURE_IDS : MAX_CONDUIT_FEATURES
+    );
+    if (!response.ok || !collection) throw new Error("Invalid WFS response");
+    return NextResponse.json(collection);
+  } catch {
+    return NextResponse.json({ code: "WFS_UNAVAILABLE" }, { status: 502 });
+  }
+}

app/api/tts/edge/route.ts

@@ -0,0 +1,59 @@
+import { Communicate } from "edge-tts-ts";
+import { NextResponse } from "next/server";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+const DEFAULT_VOICE = process.env.EDGE_TTS_VOICE || "zh-CN-XiaoxiaoNeural";
+const MAX_TEXT_LENGTH = 12_000;
+
+const jsonError = (message: string, status: number) =>
+  NextResponse.json({ error: message }, { status });
+
+export async function POST(request: Request) {
+  let payload: { text?: unknown; voice?: unknown };
+  try {
+    payload = await request.json() as { text?: unknown; voice?: unknown };
+  } catch {
+    return jsonError("请求内容不是有效 JSON", 400);
+  }
+
+  const text = typeof payload.text === "string" ? payload.text.trim() : "";
+  if (!text) return jsonError("缺少待朗读文本", 400);
+  if (text.length > MAX_TEXT_LENGTH) return jsonError(`单次文本不能超过 ${MAX_TEXT_LENGTH} 字`, 413);
+
+  const voice = typeof payload.voice === "string" && payload.voice.trim()
+    ? payload.voice.trim()
+    : DEFAULT_VOICE;
+
+  try {
+    const communicate = new Communicate(text, { voice });
+    const chunks: Uint8Array[] = [];
+    let byteLength = 0;
+
+    for await (const chunk of communicate.stream()) {
+      if (chunk.type !== "audio") continue;
+      chunks.push(chunk.data);
+      byteLength += chunk.data.byteLength;
+    }
+
+    if (!byteLength) return jsonError("语音服务返回了空音频", 502);
+
+    const audio = new Uint8Array(byteLength);
+    let offset = 0;
+    for (const chunk of chunks) {
+      audio.set(chunk, offset);
+      offset += chunk.byteLength;
+    }
+
+    return new Response(audio.buffer.slice(audio.byteOffset, audio.byteOffset + audio.byteLength), {
+      headers: {
+        "Content-Type": "audio/mpeg",
+        "Cache-Control": "no-store"
+      }
+    });
+  } catch (error) {
+    console.error("[Agent TTS] 语音生成失败", error);
+    return jsonError("语音生成失败", 502);
+  }
+}