weifuwu 0.57.0 → 0.58.0

package/dist/index.js

@@ -2578,6 +2578,377 @@ function isPoolClosed(e) {
   return /pool is closed|connection closed/.test(msg);
 }
 
+// src/ai/client.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+
+// src/ai/sse.ts
+function sseResponse(run, options) {
+  const encoder = new TextEncoder();
+  const stream = new ReadableStream({
+    async start(controller) {
+      const emit = (name, data) => {
+        controller.enqueue(encoder.encode(`event: ${name}
+data: ${JSON.stringify(data)}
+
+`));
+      };
+      try {
+        await run(emit);
+        controller.close();
+      } catch (err) {
+        try {
+          emit("wf:error", {
+            code: "provider_error",
+            message: err instanceof Error ? err.message : String(err)
+          });
+          controller.close();
+        } catch {
+          controller.error(err);
+        }
+      }
+    },
+    cancel() {
+      options?.onAbort?.();
+    }
+  });
+  return new Response(stream, {
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive"
+    }
+  });
+}
+
+// src/ai/client.ts
+var AiError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "AiError";
+    this.code = code;
+  }
+};
+async function* parseProviderSse(stream) {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith(":")) continue;
+        const data = trimmed.startsWith("data: ") ? trimmed.slice(6) : trimmed;
+        if (data === "[DONE]") return;
+        try {
+          yield JSON.parse(data);
+        } catch {
+        }
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+async function providerError(res) {
+  let message = "";
+  try {
+    const body = await res.json();
+    message = body?.error?.message ?? JSON.stringify(body);
+  } catch {
+    message = await res.text().catch(() => "");
+  }
+  const status = res.status;
+  let code;
+  if (status === 401 || status === 403) code = "auth_failed";
+  else if (status === 429) code = "rate_limited";
+  else if (status >= 500) code = "provider_error";
+  else if (/context|token|length/i.test(message)) code = "context_length";
+  else if (status === 400) code = "invalid_request";
+  else code = "provider_error";
+  return { code, message: message || `provider error (${status})` };
+}
+function createAiClient(opts) {
+  const endpoint = `${opts.baseUrl.replace(/\/$/, "")}/chat/completions`;
+  const headers = { "Content-Type": "application/json", Authorization: `Bearer ${opts.apiKey}` };
+  const approvals = /* @__PURE__ */ new Map();
+  function approve(response) {
+    const resolve3 = approvals.get(response.id);
+    if (!resolve3) return false;
+    approvals.delete(response.id);
+    resolve3(response);
+    return true;
+  }
+  async function waitApproval(req, emit, timeoutMs = DEFAULT_APPROVAL_TIMEOUT) {
+    const expiresAt = Date.now() + timeoutMs;
+    emit("wf:approval_request", { ...req, expiresAt });
+    return new Promise((resolve3) => {
+      const timer = setTimeout(() => {
+        if (approvals.has(req.id)) {
+          approvals.delete(req.id);
+          resolve3({ id: req.id, decision: "rejected" });
+        }
+      }, timeoutMs);
+      approvals.set(req.id, (resp) => {
+        clearTimeout(timer);
+        resolve3(resp);
+      });
+    });
+  }
+  function aggregateToolCalls(chunks) {
+    const calls = [];
+    for (const chunk of chunks) {
+      const delta = chunk.choices[0]?.delta;
+      if (!delta?.tool_calls) continue;
+      for (const tc of delta.tool_calls) {
+        if (tc.id) {
+          calls.push(tc);
+        } else if (calls.length > 0) {
+          const last = calls[calls.length - 1];
+          if (tc.function?.arguments) last.function.arguments += tc.function.arguments;
+        }
+      }
+    }
+    return calls;
+  }
+  async function chat(params, options) {
+    const res = await fetch(endpoint, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ ...params, model: params.model ?? opts.defaultModel, stream: false }),
+      signal: options?.signal
+    });
+    if (!res.ok) {
+      const { code, message } = await providerError(res);
+      throw new AiError(code, message);
+    }
+    return res.json();
+  }
+  function stream(params, options) {
+    const controller = new AbortController();
+    const external = options?.signal;
+    if (external) {
+      if (external.aborted) controller.abort();
+      else external.addEventListener("abort", () => controller.abort(), { once: true });
+    }
+    return sseResponse(
+      async (emit) => {
+        emit("wf:message_start", { id: options?.traceId ?? randomUUID2() });
+        await streamStep(params, {
+          emit,
+          signal: controller.signal,
+          onFinish: (r) => emit("wf:done", { content: r.content, usage: r.usage })
+        });
+      },
+      { onAbort: () => controller.abort() }
+    );
+  }
+  async function streamStep(params, stepOpts) {
+    const { emit, signal } = stepOpts;
+    let res;
+    try {
+      res = await fetch(endpoint, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({ ...params, model: params.model ?? opts.defaultModel, stream: true }),
+        signal
+      });
+    } catch (err) {
+      if (signal?.aborted) return;
+      emit("wf:error", { code: "provider_error", message: err instanceof Error ? err.message : String(err) });
+      return;
+    }
+    if (!res.ok) {
+      const { code, message } = await providerError(res);
+      emit("wf:error", { code, message });
+      return;
+    }
+    let content = "";
+    let reasoning = "";
+    const chunks = [];
+    let usage;
+    try {
+      for await (const chunk of parseProviderSse(res.body)) {
+        if (signal?.aborted) return;
+        const delta = chunk.choices[0]?.delta;
+        if (delta?.content) {
+          content += delta.content;
+          emit("wf:token", { text: delta.content });
+        }
+        if (delta?.reasoning_content) reasoning += delta.reasoning_content;
+        if (delta?.tool_calls) chunks.push(chunk);
+        if (chunk.usage) usage = chunk.usage;
+      }
+    } catch (err) {
+      if (signal?.aborted) return;
+      emit("wf:error", { code: "provider_error", message: err instanceof Error ? err.message : String(err) });
+      return;
+    }
+    const toolCalls = aggregateToolCalls(chunks);
+    for (const tc of toolCalls) {
+      emit("wf:tool_call", {
+        id: tc.id,
+        name: tc.function?.name ?? "",
+        args: safeParseArgs(tc.function?.arguments ?? "")
+      });
+    }
+    if (usage && stepOpts.emitUsage !== false) emit("wf:usage", usage);
+    stepOpts.onFinish?.({ content, reasoning_content: reasoning || void 0, toolCalls, usage });
+  }
+  function sse(run, options) {
+    const controller = new AbortController();
+    const external = options?.signal;
+    if (external) {
+      if (external.aborted) controller.abort();
+      else external.addEventListener("abort", () => controller.abort(), { once: true });
+    }
+    return sseResponse(run, { onAbort: () => controller.abort() });
+  }
+  return { chat, stream, sse, streamStep, waitApproval, approve };
+}
+var DEFAULT_APPROVAL_TIMEOUT = 5 * 6e4;
+function safeParseArgs(raw) {
+  if (!raw) return {};
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+
+// src/ai/agent.ts
+import { randomUUID as randomUUID3 } from "node:crypto";
+function createAgent(client, config) {
+  const maxSteps = config.maxSteps ?? 10;
+  const toolDefs = config.tools.map((t) => ({
+    type: "function",
+    function: { name: t.name, description: t.description ?? "", parameters: t.parameters ?? {} }
+  }));
+  function run(messages, options) {
+    const controller = new AbortController();
+    const external = options?.signal;
+    if (external) {
+      if (external.aborted) controller.abort();
+      else external.addEventListener("abort", () => controller.abort(), { once: true });
+    }
+    return sseResponse(
+      async (emit) => {
+        emit("wf:message_start", { id: options?.traceId ?? randomUUID3() });
+        await loop(messages, emit, controller.signal);
+      },
+      { onAbort: () => controller.abort() }
+    );
+  }
+  async function loop(messages, emit, signal) {
+    const all = [{ role: "system", content: config.systemPrompt }, ...messages];
+    const usage = { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 };
+    for (let step = 0; step < maxSteps; step++) {
+      if (signal?.aborted) return;
+      emit("wf:step", { type: "llm" });
+      let finish = { content: "", toolCalls: [] };
+      await client.streamStep(
+        { model: config.model, messages: all, tools: toolDefs },
+        {
+          emit,
+          signal,
+          emitUsage: false,
+          // agent 只发累积 usage（done 前统一发）
+          onFinish: (r) => {
+            finish = r;
+            if (r.usage) {
+              usage.prompt_tokens += r.usage.prompt_tokens ?? 0;
+              usage.completion_tokens += r.usage.completion_tokens ?? 0;
+              usage.total_tokens += r.usage.total_tokens ?? 0;
+            }
+          }
+        }
+      );
+      if (signal?.aborted) return;
+      if (!finish.toolCalls?.length) {
+        emit("wf:usage", usage);
+        emit("wf:done", { content: finish.content, usage });
+        return;
+      }
+      all.push({
+        role: "assistant",
+        content: finish.content ?? "",
+        reasoning_content: finish.reasoning_content,
+        tool_calls: finish.toolCalls
+      });
+      for (const tc of finish.toolCalls) {
+        if (signal?.aborted) return;
+        const name = tc.function?.name ?? "";
+        const args = safeParseArgs(tc.function?.arguments ?? "");
+        emit("wf:step", { type: "tool", toolCallId: tc.id, name });
+        let execArgs = args;
+        if (config.humanInTheLoop) {
+          const decision = await client.waitApproval(
+            { id: randomUUID3(), toolCallId: tc.id, name, args },
+            emit,
+            config.approvalTimeoutMs
+          );
+          if (decision.decision === "rejected") {
+            emit("wf:tool_result", { id: tc.id, ok: false, error: { code: "rejected", message: decision.note ?? "\u7528\u6237\u62D2\u7EDD" } });
+            all.push({ role: "tool", content: `Human rejected: ${decision.note ?? ""}`, tool_call_id: tc.id, name });
+            continue;
+          }
+          if (decision.decision === "modified" && decision.modifiedArgs) execArgs = decision.modifiedArgs;
+        }
+        const tool = config.tools.find((t) => t.name === name);
+        if (!tool) {
+          emit("wf:tool_result", { id: tc.id, ok: false, error: { code: "tool_error", message: `\u5DE5\u5177\u4E0D\u5B58\u5728: ${name}` } });
+          all.push({ role: "tool", content: `Error: tool not found: ${name}`, tool_call_id: tc.id, name });
+          continue;
+        }
+        try {
+          const output = await tool.run(execArgs, { emit, signal });
+          emit("wf:tool_result", { id: tc.id, ok: true, output });
+          all.push({ role: "tool", content: JSON.stringify(output ?? ""), tool_call_id: tc.id, name });
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          emit("wf:tool_result", { id: tc.id, ok: false, error: { code: "tool_error", message: msg } });
+          all.push({ role: "tool", content: `Error: ${msg}`, tool_call_id: tc.id, name });
+        }
+      }
+    }
+    emit("wf:usage", usage);
+    emit("wf:done", { content: "", usage });
+  }
+  return { run };
+}
+
+// src/ai/index.ts
+function ai(options) {
+  const apiKey = options?.apiKey ?? process.env.DEEPSEEK_API_KEY ?? "";
+  const baseUrl = options?.baseUrl ?? process.env.DEEPSEEK_BASE_URL ?? "https://api.deepseek.com/v1";
+  const defaultModel = options?.defaultModel ?? process.env.DEEPSEEK_MODEL ?? "deepseek-v4-flash";
+  if (!apiKey) {
+    throw new Error("ai: DEEPSEEK_API_KEY \u672A\u8BBE\u7F6E\u3002\u8BF7\u8BBE\u7F6E\u73AF\u5883\u53D8\u91CF\u6216\u4F20\u5165 apiKey");
+  }
+  const client = createAiClient({ apiKey, baseUrl, defaultModel });
+  const mw = (req, ctx, next) => {
+    ctx.ai = module;
+    return next(req, ctx);
+  };
+  mw.__meta = { injects: ["ai"], depends: [] };
+  const module = mw;
+  module.chat = client.chat;
+  module.stream = client.stream;
+  module.sse = client.sse;
+  module.streamStep = client.streamStep;
+  module.waitApproval = client.waitApproval;
+  module.approve = client.approve;
+  module.agent = (config) => createAgent(client, config);
+  module.close = async () => {
+  };
+  return module;
+}
+
 // src/ui/index.ts
 import { build } from "esbuild";
 import { readFile, stat } from "node:fs/promises";
@@ -4148,6 +4519,7 @@ export {
   HttpError,
   MIGRATIONS_TABLE,
   Router,
+  ai,
   badRequest,
   conflict,
   cors,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "weifuwu",
   "type": "module",
-  "version": "0.57.0",
+  "version": "0.58.0",
   "description": "AI SaaS framework — (req, ctx) => Response",
   "exports": {
     ".": {