weifuwu 0.60.0 → 0.61.0

package/dist/index.js

@@ -1513,7 +1513,11 @@ function userSystem(options) {
     return rows.length ? rows[0] : null;
   }
   async function issueSession(user) {
-    const token = signToken({ sub: user.id }, secret, accessTtlSeconds);
+    const token = signToken(
+      { sub: user.id, ...user.tenant ? { tenantId: user.tenant } : {} },
+      secret,
+      accessTtlSeconds
+    );
     const refreshToken = generateRefreshToken();
     const expiresAt = new Date(Date.now() + refreshTtlDays * 24 * 3600 * 1e3);
     await sql.unsafe(
@@ -1539,15 +1543,26 @@ function userSystem(options) {
   }
   const mw = (async (req, ctx, next) => {
     currentUser = null;
+    const sessionPayload = {};
+    let payloadTenantId;
     const authHeader = req.headers.get("authorization");
     if (authHeader?.startsWith("Bearer ")) {
       const payload = verifyToken(authHeader.slice(7), secret);
       if (payload?.sub) {
         currentUser = await findUserById(String(payload.sub));
+        for (const [k, v] of Object.entries(payload)) {
+          if (k === "sub" || k === "iat" || k === "exp" || k === "type") continue;
+          sessionPayload[k] = v;
+        }
+        sessionPayload.userId = String(payload.sub);
+        payloadTenantId = payload.tenantId;
       }
     }
     ctx.user = currentUser;
+    if (payloadTenantId != null) ctx.tenantId = String(payloadTenantId);
     ctx.auth = {
+      // ── 会话 payload 字段（来自 token，应用层签发时决定带什么） ──
+      ...sessionPayload,
       async register(input) {
         if (!input.email || !input.password) throw new HttpError("email and password are required", 400);
         if (input.password.length < 8) throw new HttpError("password must be at least 8 characters", 400);
@@ -1630,24 +1645,25 @@ function userSystem(options) {
   };
   mw.routes = (app, routeOpts) => {
     const p = routeOpts?.prefix ?? prefix;
-    app.post(`${p}/register`, async (req, ctx) => {
+    const excluded = new Set(routeOpts?.exclude ?? []);
+    if (!excluded.has("register")) app.post(`${p}/register`, async (req, ctx) => {
       const body = await req.json().catch(() => ({}));
       const result = await ctx.auth.register(body);
       return created(result);
     });
-    app.post(`${p}/login`, async (req, ctx) => {
+    if (!excluded.has("login")) app.post(`${p}/login`, async (req, ctx) => {
       const body = await req.json().catch(() => ({}));
       if (!body.email || !body.password) return badRequest("email and password are required");
       const result = await ctx.auth.login(body.email, body.password);
       return ok(result);
     });
-    app.post(`${p}/logout`, async (req, ctx) => {
+    if (!excluded.has("logout")) app.post(`${p}/logout`, async (req, ctx) => {
       const body = await req.json().catch(() => ({}));
       if (!body.refreshToken) return badRequest("refreshToken is required");
       await ctx.auth.logout(body.refreshToken);
       return noContent();
     });
-    app.post(`${p}/refresh`, async (req, ctx) => {
+    if (!excluded.has("refresh")) app.post(`${p}/refresh`, async (req, ctx) => {
       const body = await req.json().catch(() => ({}));
       if (!body.refreshToken) throw new HttpError("refreshToken is required", 400);
       const user = await consumeRefreshToken(body.refreshToken);
@@ -1655,7 +1671,7 @@ function userSystem(options) {
       const session = await issueSession(user);
       return ok({ ...session, user });
     });
-    app.get(`${p}/me`, async (_req, ctx) => {
+    if (!excluded.has("me")) app.get(`${p}/me`, async (_req, ctx) => {
       if (!ctx.user) throw new HttpError("Unauthorized", 401);
       return ok(ctx.user);
     });
@@ -1663,6 +1679,403 @@ function userSystem(options) {
   return mw;
 }
 
+// src/messager/index.ts
+var CONVERSATIONS = "_weifuwu_conversations";
+var MEMBERS = "_weifuwu_conversation_members";
+var MESSAGES = "_weifuwu_messages";
+function messager(options) {
+  const sql = options.sql;
+  const prefix = options.prefix ?? "/api/messages";
+  async function createConversation(userId, input) {
+    if (input.type === "direct") {
+      const existing = await sql.unsafe(
+        `SELECT c.id, c.type, c.created_by, c.created_at FROM ${CONVERSATIONS} c
+         WHERE c.type = 'direct'
+           AND EXISTS (SELECT 1 FROM ${MEMBERS} m WHERE m.conversation_id = c.id AND m.user_id = $1)
+           AND EXISTS (SELECT 1 FROM ${MEMBERS} m WHERE m.conversation_id = c.id AND m.user_id = $2)
+           AND (SELECT count(*) FROM ${MEMBERS} m WHERE m.conversation_id = c.id) = 2
+         LIMIT 1`,
+        [userId, input.otherUserId]
+      );
+      if (existing.length) return existing[0];
+      return createConversationRow(userId, "direct", [userId, input.otherUserId]);
+    }
+    const memberIds = [userId, ...input.memberIds.filter((m) => m !== userId)];
+    return createConversationRow(userId, "group", memberIds);
+  }
+  async function createConversationRow(createdBy, type, memberIds) {
+    await sql.unsafe(`BEGIN`);
+    try {
+      const rows = await sql.unsafe(
+        `INSERT INTO ${CONVERSATIONS} (type, created_by) VALUES ($1, $2) RETURNING id, type, created_by, created_at`,
+        [type, createdBy]
+      );
+      const conv = rows[0];
+      for (const memberId of memberIds) {
+        await sql.unsafe(
+          `INSERT INTO ${MEMBERS} (conversation_id, user_id) VALUES ($1, $2) ON CONFLICT DO NOTHING`,
+          [conv.id, memberId]
+        );
+      }
+      await sql.unsafe(`COMMIT`);
+      return conv;
+    } catch (err) {
+      await sql.unsafe(`ROLLBACK`);
+      throw err;
+    }
+  }
+  async function listConversations(userId) {
+    const rows = await sql.unsafe(
+      `SELECT c.id, c.type, c.created_by, c.created_at,
+         (SELECT to_jsonb(m) FROM ${MESSAGES} m
+          WHERE m.conversation_id = c.id AND m.deleted_at IS NULL
+          ORDER BY m.created_at DESC, m.id DESC LIMIT 1) AS last_message,
+         (SELECT count(*) FROM ${MESSAGES} m
+          WHERE m.conversation_id = c.id AND m.deleted_at IS NULL
+            AND m.sender_id IS DISTINCT FROM $1
+            AND m.created_at > COALESCE(mem.last_read_at, 'epoch'::timestamptz)) AS unread_count
+       FROM ${CONVERSATIONS} c
+       JOIN ${MEMBERS} mem ON mem.conversation_id = c.id
+       WHERE mem.user_id = $1
+       ORDER BY c.created_at DESC`,
+      [userId]
+    );
+    return rows.map((r) => {
+      const conv = r;
+      const last = conv.last_message;
+      return {
+        id: conv.id,
+        type: conv.type,
+        created_by: conv.created_by,
+        created_at: new Date(conv.created_at).toISOString(),
+        last_message: last && typeof last === "object" ? normalizeMessage(last) : null,
+        unread_count: Number(conv.unread_count)
+      };
+    });
+  }
+  async function getConversationForUser(conversationId, userId) {
+    if (!await isMember(conversationId, userId)) return null;
+    const rows = await sql.unsafe(
+      `SELECT id, type, created_by, created_at FROM ${CONVERSATIONS} WHERE id = $1`,
+      [conversationId]
+    );
+    return rows.length ? rows[0] : null;
+  }
+  async function isMember(conversationId, userId) {
+    const rows = await sql.unsafe(
+      `SELECT 1 FROM ${MEMBERS} WHERE conversation_id = $1 AND user_id = $2`,
+      [conversationId, userId]
+    );
+    return rows.length > 0;
+  }
+  async function sendMessage(conversationId, input) {
+    const rows = await sql.unsafe(
+      `INSERT INTO ${MESSAGES} (conversation_id, sender_type, sender_id, content, msg_type)
+       VALUES ($1, $2, $3, $4, $5) RETURNING *`,
+      [conversationId, input.senderType, input.senderId ?? null, input.content, input.msgType ?? "text"]
+    );
+    return normalizeMessage(rows[0]);
+  }
+  async function listMessages(conversationId, opts) {
+    const limit = opts.limit ?? 50;
+    const rows = await sql.unsafe(
+      `SELECT * FROM ${MESSAGES}
+       WHERE conversation_id = $1
+         AND ($2::uuid IS NULL OR (created_at, id) < (SELECT created_at, id FROM ${MESSAGES} WHERE id = $2))
+       ORDER BY created_at DESC, id DESC
+       LIMIT $3`,
+      [conversationId, opts.before ?? null, limit]
+    );
+    return rows.map(normalizeMessage);
+  }
+  async function editMessage(messageId, content) {
+    const rows = await sql.unsafe(
+      `UPDATE ${MESSAGES} SET content = $2, edited_at = now()
+       WHERE id = $1 AND deleted_at IS NULL RETURNING *`,
+      [messageId, content]
+    );
+    return rows.length ? normalizeMessage(rows[0]) : null;
+  }
+  async function deleteMessage(messageId) {
+    const rows = await sql.unsafe(
+      `UPDATE ${MESSAGES} SET deleted_at = now() WHERE id = $1 AND deleted_at IS NULL RETURNING id`,
+      [messageId]
+    );
+    return rows.length > 0;
+  }
+  async function markRead(conversationId, userId) {
+    await sql.unsafe(
+      `UPDATE ${MEMBERS} SET last_read_at = now() WHERE conversation_id = $1 AND user_id = $2`,
+      [conversationId, userId]
+    );
+  }
+  function normalizeMessage(row) {
+    return {
+      id: row.id,
+      conversation_id: row.conversation_id,
+      sender_type: row.sender_type,
+      sender_id: row.sender_id,
+      content: row.content,
+      msg_type: row.msg_type,
+      created_at: new Date(row.created_at).toISOString(),
+      edited_at: row.edited_at ? new Date(row.edited_at).toISOString() : null,
+      deleted_at: row.deleted_at ? new Date(row.deleted_at).toISOString() : null
+    };
+  }
+  const REDIS_PREFIX = "wf:msg:";
+  const rooms = /* @__PURE__ */ new Map();
+  const wsRooms = /* @__PURE__ */ new Map();
+  let redisSub = null;
+  function initRedis() {
+    const pool = options.redis?.redis;
+    if (!pool || redisSub) return;
+    redisSub = pool.createSubscriber();
+    redisSub.connect().then(() => {
+      redisSub.psubscribe(`${REDIS_PREFIX}*`, (channel, message) => {
+        const room = channel.slice(REDIS_PREFIX.length);
+        const event = JSON.parse(message);
+        broadcastLocal(room, event);
+      });
+    }).catch((err) => {
+      console.error("[messager] redis subscriber init error:", err);
+    });
+  }
+  function broadcastLocal(room, event) {
+    const members = rooms.get(room);
+    if (!members) return;
+    const payload = JSON.stringify(event);
+    for (const ws of [...members]) {
+      if (ws.readyState === ws.OPEN) {
+        try {
+          ws.send(payload);
+        } catch {
+        }
+      }
+    }
+  }
+  function broadcast(room, event) {
+    broadcastLocal(room, event);
+    const pool = options.redis?.redis;
+    if (pool) {
+      pool.publish(`${REDIS_PREFIX}${room}`, JSON.stringify(event)).catch((err) => {
+        console.error("[messager] redis publish error:", err);
+      });
+    }
+  }
+  function sendTo(userId, event) {
+    broadcast(`user:${userId}`, event);
+  }
+  function join(room, ws) {
+    let members = rooms.get(room);
+    if (!members) {
+      members = /* @__PURE__ */ new Set();
+      rooms.set(room, members);
+    }
+    members.add(ws);
+    let joined = wsRooms.get(ws);
+    if (!joined) {
+      joined = /* @__PURE__ */ new Set();
+      wsRooms.set(ws, joined);
+    }
+    joined.add(room);
+  }
+  function leave(room, ws) {
+    rooms.get(room)?.delete(ws);
+    if (rooms.get(room)?.size === 0) rooms.delete(room);
+    wsRooms.get(ws)?.delete(room);
+  }
+  function leaveAll(ws) {
+    const joined = wsRooms.get(ws);
+    if (joined) for (const room of [...joined]) leave(room, ws);
+    wsRooms.delete(ws);
+  }
+  function handler() {
+    return {
+      open(ws) {
+        ws.send(JSON.stringify({ type: "connected" }));
+      },
+      message(ws, _ctx, data) {
+        try {
+          const msg = JSON.parse(data.toString());
+          if (msg.type === "ping") {
+            ws.send(JSON.stringify({ type: "pong" }));
+          } else if (msg.type === "subscribe" && msg.room) {
+            join(msg.room, ws);
+            ws.send(JSON.stringify({ type: "subscribed", room: msg.room }));
+          } else if (msg.type === "unsubscribe" && msg.room) {
+            leave(msg.room, ws);
+          }
+        } catch {
+        }
+      },
+      close(ws) {
+        leaveAll(ws);
+      },
+      error(ws) {
+        leaveAll(ws);
+      }
+    };
+  }
+  async function close() {
+    if (redisSub) {
+      try {
+        await redisSub.close?.();
+      } catch {
+      }
+      redisSub = null;
+    }
+    rooms.clear();
+    wsRooms.clear();
+  }
+  const client = {
+    handler,
+    broadcast,
+    sendTo,
+    join,
+    leave,
+    close,
+    createConversation,
+    listConversations,
+    getConversationForUser,
+    isMember,
+    sendMessage,
+    listMessages,
+    editMessage,
+    deleteMessage,
+    markRead
+  };
+  initRedis();
+  const mw = (async (req, ctx, next) => {
+    ctx.msg = client;
+    return next(req, ctx);
+  });
+  mw.client = client;
+  mw.__meta = { injects: ["msg"], depends: ["sql"] };
+  mw.migrate = async () => {
+    await sql.unsafe(`
+      CREATE TABLE IF NOT EXISTS ${CONVERSATIONS} (
+        id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+        type TEXT NOT NULL DEFAULT 'direct',
+        created_by UUID,
+        created_at TIMESTAMPTZ NOT NULL DEFAULT now()
+      )
+    `);
+    await sql.unsafe(`
+      CREATE TABLE IF NOT EXISTS ${MEMBERS} (
+        conversation_id UUID NOT NULL REFERENCES ${CONVERSATIONS}(id) ON DELETE CASCADE,
+        user_id UUID NOT NULL,
+        last_read_at TIMESTAMPTZ,
+        joined_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+        PRIMARY KEY (conversation_id, user_id)
+      )
+    `);
+    await sql.unsafe(`
+      CREATE TABLE IF NOT EXISTS ${MESSAGES} (
+        id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+        conversation_id UUID NOT NULL REFERENCES ${CONVERSATIONS}(id) ON DELETE CASCADE,
+        sender_type TEXT NOT NULL DEFAULT 'user',
+        sender_id UUID,
+        content TEXT NOT NULL,
+        msg_type TEXT NOT NULL DEFAULT 'text',
+        created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+        edited_at TIMESTAMPTZ,
+        deleted_at TIMESTAMPTZ
+      )
+    `);
+    await sql.unsafe(`
+      CREATE INDEX IF NOT EXISTS idx_messages_conv ON ${MESSAGES} (conversation_id, created_at DESC, id DESC)
+    `);
+  };
+  mw.routes = (app, routeOpts) => {
+    const p = routeOpts?.prefix ?? prefix;
+    async function requireMember(conversationId, ctx) {
+      if (!ctx.user) throw new HttpError("Unauthorized", 401);
+      if (!await isMember(conversationId, ctx.user.id)) {
+        throw new HttpError("Forbidden: not a conversation member", 403);
+      }
+    }
+    app.post(`${p}/conversations`, async (req, ctx) => {
+      if (!ctx.user) throw new HttpError("Unauthorized", 401);
+      const body = await req.json().catch(() => ({}));
+      if (body.type === "direct" && body.otherUserId) {
+        const conv = await createConversation(ctx.user.id, { type: "direct", otherUserId: body.otherUserId });
+        return created(conv);
+      }
+      if (body.type === "group" && Array.isArray(body.memberIds)) {
+        const conv = await createConversation(ctx.user.id, { type: "group", memberIds: body.memberIds });
+        return created(conv);
+      }
+      return badRequest("conversation input invalid");
+    });
+    app.get(`${p}/conversations`, async (_req, ctx) => {
+      if (!ctx.user) throw new HttpError("Unauthorized", 401);
+      return ok(await listConversations(ctx.user.id));
+    });
+    app.get(`${p}/conversations/:id/messages`, async (req, ctx) => {
+      if (!ctx.user) throw new HttpError("Unauthorized", 401);
+      const convId = ctx.params.id;
+      await requireMember(convId, ctx);
+      const url = new URL(req.url);
+      const before = url.searchParams.get("before") ?? void 0;
+      const limit = Number(url.searchParams.get("limit") ?? 50);
+      return ok(await listMessages(convId, { before, limit }));
+    });
+    app.post(`${p}/conversations/:id/messages`, async (req, ctx) => {
+      if (!ctx.user) throw new HttpError("Unauthorized", 401);
+      const convId = ctx.params.id;
+      await requireMember(convId, ctx);
+      const body = await req.json().catch(() => ({}));
+      if (!body.content?.trim()) return badRequest("content is required");
+      const message = await sendMessage(convId, {
+        senderType: "user",
+        senderId: ctx.user.id,
+        content: body.content,
+        msgType: body.msgType ?? "text"
+      });
+      broadcast(`conv:${convId}`, { type: "new_message", message });
+      return created(message);
+    });
+    app.post(`${p}/conversations/:id/read`, async (_req, ctx) => {
+      if (!ctx.user) throw new HttpError("Unauthorized", 401);
+      const convId = ctx.params.id;
+      await requireMember(convId, ctx);
+      await markRead(convId, ctx.user.id);
+      return noContent();
+    });
+    app.patch(`${p}/messages/:id`, async (req, ctx) => {
+      if (!ctx.user) throw new HttpError("Unauthorized", 401);
+      const messageId = ctx.params.id;
+      const body = await req.json().catch(() => ({}));
+      if (!body.content?.trim()) return badRequest("content is required");
+      const edited = await editMessage(messageId, body.content);
+      if (!edited) return badRequest("message not found");
+      if (edited.sender_type === "user" && edited.sender_id !== ctx.user.id) {
+        throw new HttpError("Forbidden: not your message", 403);
+      }
+      broadcast(`conv:${edited.conversation_id}`, { type: "message_edited", message: edited });
+      return ok(edited);
+    });
+    app.delete(`${p}/messages/:id`, async (req, ctx) => {
+      if (!ctx.user) throw new HttpError("Unauthorized", 401);
+      const messageId = ctx.params.id;
+      const list = await sql.unsafe(
+        `SELECT conversation_id, sender_type, sender_id FROM ${MESSAGES} WHERE id = $1`,
+        [messageId]
+      );
+      if (!list.length) return badRequest("message not found");
+      const row = list[0];
+      if (row.sender_type === "user" && row.sender_id !== ctx.user.id) {
+        throw new HttpError("Forbidden: not your message", 403);
+      }
+      await requireMember(row.conversation_id, ctx);
+      await deleteMessage(messageId);
+      broadcast(`conv:${row.conversation_id}`, { type: "message_deleted", messageId });
+      return noContent();
+    });
+  };
+  return mw;
+}
+
 // src/queue/index.ts
 import { randomUUID } from "node:crypto";
 import { hostname } from "node:os";
@@ -2674,9 +3087,56 @@ async function providerError(res) {
   else code = "provider_error";
   return { code, message: message || `provider error (${status})` };
 }
+function createEmbeddingClient(ebd) {
+  const apiKey = ebd?.apiKey ?? process.env.DASHSCOPE_API_KEY ?? "";
+  const configured = !!(ebd?.apiKey || process.env.DASHSCOPE_API_KEY);
+  const baseUrl = ebd?.baseUrl ?? process.env.DASHSCOPE_BASE_URL ?? "https://dashscope.aliyuncs.com/compatible-mode/v1";
+  const defaultModel = ebd?.defaultModel ?? process.env.DASHSCOPE_EMBEDDING_MODEL ?? "text-embedding-v4";
+  const endpoint = `${baseUrl.replace(/\/$/, "")}/embeddings`;
+  const headers = { "Content-Type": "application/json", Authorization: `Bearer ${apiKey}` };
+  async function embedMany(texts) {
+    if (!configured) {
+      throw new AiError("unsupported", "ai embedding: \u672A\u914D\u7F6E\u2014\u2014\u4F20 ai({ embedding }) \u6216\u8BBE DASHSCOPE_API_KEY\uFF08DeepSeek \u65E0 embedding API\uFF0C\u9700\u72EC\u7ACB provider\uFF09");
+    }
+    if (!apiKey) {
+      throw new AiError("auth_failed", "ai embedding: DASHSCOPE_API_KEY \u672A\u8BBE\u7F6E");
+    }
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 3e3);
+    let res;
+    try {
+      res = await fetch(endpoint, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({ model: defaultModel, input: texts }),
+        signal: controller.signal
+      });
+    } catch (err) {
+      if (controller.signal.aborted) throw new AiError("provider_error", "embedding \u8BF7\u6C42\u8D85\u65F6\uFF083s\uFF09");
+      throw new AiError("provider_error", err instanceof Error ? err.message : String(err));
+    } finally {
+      clearTimeout(timer);
+    }
+    if (!res.ok) {
+      const { code, message } = await providerError(res);
+      throw new AiError(code, message);
+    }
+    const data = await res.json();
+    data.data.sort((a, b) => a.index - b.index);
+    return data.data.map((item) => item.embedding);
+  }
+  return {
+    async embed(text) {
+      const results = await embedMany([text]);
+      return results[0];
+    },
+    embedMany
+  };
+}
 function createAiClient(opts) {
   const endpoint = `${opts.baseUrl.replace(/\/$/, "")}/chat/completions`;
   const headers = { "Content-Type": "application/json", Authorization: `Bearer ${opts.apiKey}` };
+  const embedding = createEmbeddingClient(opts.embedding);
   const approvals = /* @__PURE__ */ new Map();
   function approve(response) {
     const resolve3 = approvals.get(response.id);
@@ -2810,7 +3270,17 @@ function createAiClient(opts) {
     }
     return sseResponse(run, { onAbort: () => controller.abort() });
   }
-  return { chat, stream, sse, streamStep, waitApproval, approve };
+  return {
+    chat,
+    stream,
+    sse,
+    streamStep,
+    waitApproval,
+    approve,
+    // embedding：未配置 provider 时明确抛 AiError（诚实裁剪：不静默降级）
+    embed: (text) => embedding.embed(text),
+    embedMany: (texts) => embedding.embedMany(texts)
+  };
 }
 var DEFAULT_APPROVAL_TIMEOUT = 5 * 6e4;
 function safeParseArgs(raw) {
@@ -2830,13 +3300,23 @@ function createAgent(client, config) {
     type: "function",
     function: { name: t.name, description: t.description ?? "", parameters: t.parameters ?? {} }
   }));
-  function run(messages, options) {
+  function createController(external) {
     const controller = new AbortController();
-    const external = options?.signal;
     if (external) {
       if (external.aborted) controller.abort();
       else external.addEventListener("abort", () => controller.abort(), { once: true });
     }
+    return controller;
+  }
+  async function stream(messages, options) {
+    const controller = createController(options?.signal);
+    const emit = options?.emit ?? (() => {
+    });
+    emit("wf:message_start", { id: options?.traceId ?? randomUUID3() });
+    await loop(messages, emit, controller.signal);
+  }
+  function run(messages, options) {
+    const controller = createController(options?.signal);
     return sseResponse(
       async (emit) => {
         emit("wf:message_start", { id: options?.traceId ?? randomUUID3() });
@@ -2845,6 +3325,35 @@ function createAgent(client, config) {
       { onAbort: () => controller.abort() }
     );
   }
+  async function runToResult(messages, options) {
+    let content = "";
+    const steps = [];
+    let usage;
+    const emit = (name, data) => {
+      if (name === "wf:token") {
+        content += data.text;
+      } else if (name === "wf:step") {
+        const s = data;
+        if (s.type === "llm") steps.push({ type: "llm", content: s.content });
+        else steps.push({ type: "tool_call", toolCall: { id: s.toolCallId ?? "", name: s.name ?? "", arguments: "" } });
+      } else if (name === "wf:tool_result") {
+        const r = data;
+        const last = steps[steps.length - 1];
+        if (last && last.type === "tool_call") {
+          steps[steps.length - 1] = {
+            type: "tool_result",
+            toolCall: last.toolCall,
+            toolResult: r.ok ? JSON.stringify(r.output ?? "") : `Error: ${r.error?.message ?? "unknown"}`
+          };
+        }
+      } else if (name === "wf:usage") {
+        usage = data;
+      }
+    };
+    const controller = createController(options?.signal);
+    await loop(messages, emit, controller.signal);
+    return { content, steps, usage };
+  }
   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 };
@@ -2920,7 +3429,7 @@ function createAgent(client, config) {
     emit("wf:usage", usage);
     emit("wf:done", { content: "", usage });
   }
-  return { run };
+  return { run, stream, runToResult };
 }
 
 // src/ai/index.ts
@@ -2931,7 +3440,7 @@ function ai(options) {
   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 client = createAiClient({ apiKey, baseUrl, defaultModel, embedding: options?.embedding });
   const mw = (req, ctx, next) => {
     ctx.ai = module;
     return next(req, ctx);
@@ -2945,6 +3454,8 @@ function ai(options) {
   module.waitApproval = client.waitApproval;
   module.approve = client.approve;
   module.agent = (config) => createAgent(client, config);
+  module.embed = client.embed;
+  module.embedMany = client.embedMany;
   module.close = async () => {
   };
   return module;
@@ -4563,6 +5074,7 @@ export {
   created,
   email,
   forbidden,
+  messager,
   noContent,
   notFound,
   ok,