weifuwu 0.10.0 → 0.12.0

package/dist/index.js

@@ -63,6 +63,11 @@ async function sendResponse(res, response) {
   }
   res.end();
 }
+async function createTestServer(handler) {
+  const server = serve(handler, { port: 0 });
+  await server.ready;
+  return { server, url: `http://localhost:${server.port}` };
+}
 function serve(handler, options) {
   const port = options?.port ?? 0;
   const hostname = options?.hostname ?? "0.0.0.0";
@@ -329,13 +334,13 @@ var Router = class _Router {
             const mw = match.middlewares[index++];
             return mw(innerReq, ctx2, dispatch);
           }
-          return await new Promise((resolve9) => {
+          return await new Promise((resolve10) => {
             try {
               upgradeSocket(router.wss, req, socket, head, match.handler, ctx2);
-              resolve9(new Response(null, { status: 101 }));
+              resolve10(new Response(null, { status: 101 }));
             } catch {
               socket.destroy();
-              resolve9(new Response("WebSocket upgrade failed", { status: 500 }));
+              resolve10(new Response("WebSocket upgrade failed", { status: 500 }));
             }
           });
         };
@@ -1946,37 +1951,39 @@ function graphql(handler) {
     }
     return executeQuery(schema, params, options, req, ctx);
   });
-  return r;
+  return { router: () => r };
 }
 
 // ai.ts
-var _ai = {
-  streamText: null
-};
-async function ai(handler) {
-  if (!_ai.streamText) {
-    _ai.streamText = (await import("ai")).streamText;
-  }
+var _ai = {};
+async function getStreamText() {
+  if (!_ai.streamText) _ai.streamText = (await import("ai")).streamText;
+  return _ai.streamText;
+}
+async function getStreamObject() {
+  if (!_ai.streamObject) _ai.streamObject = (await import("ai")).streamObject;
+  return _ai.streamObject;
+}
+async function aiStream(handler) {
   const r = new Router();
   r.post("/", async (req, ctx) => {
     const options = await handler(req, ctx);
-    const result = _ai.streamText(options);
+    if (options.schema) {
+      const streamObject = await getStreamObject();
+      const { schema, ...params } = options;
+      const result2 = streamObject({ ...params, schema, output: "object" });
+      return result2.toTextStreamResponse();
+    }
+    const streamText3 = await getStreamText();
+    const result = streamText3(options);
     return result.toTextStreamResponse();
   });
-  return r;
+  return { router: () => r };
 }
 
-// workflow/tool.ts
-function tool(def) {
-  return {
-    name: def.name ?? "",
-    description: def.description,
-    inputSchema: def.inputSchema,
-    execute: def.execute
-  };
-}
-
-// workflow/reference.ts
+// ai/workflow.ts
+import { tool, generateText } from "ai";
+import { z } from "zod";
 var DANGEROUS_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
 function getByPath(obj, path2) {
   let current = obj;
@@ -1993,33 +2000,21 @@ function getByPath(obj, path2) {
 }
 function resolveRef(path2, ctx) {
   if (path2.startsWith("$nodes.")) {
-    const afterNodes = path2.slice(7);
-    const dotIdx = afterNodes.indexOf(".");
-    if (dotIdx === -1) {
-      return ctx.nodeOutputs.get(afterNodes);
-    }
-    const id2 = afterNodes.slice(0, dotIdx);
-    const propPath = afterNodes.slice(dotIdx + 1);
+    const after = path2.slice(7);
+    const dot = after.indexOf(".");
+    if (dot === -1) return ctx.nodeOutputs.get(after);
+    const id2 = after.slice(0, dot);
+    const propPath = after.slice(dot + 1);
     const output = ctx.nodeOutputs.get(id2);
-    if (output === void 0) {
-      throw new Error(`Node "${id2}" has no output yet`);
-    }
-    if (propPath.startsWith("output")) {
-      return getByPath(output, propPath.slice(7).split(".").filter(Boolean));
-    }
-    return getByPath(output, propPath.split("."));
+    if (output === void 0) throw new Error(`Node "${id2}" has no output yet`);
+    return getByPath(output, propPath.startsWith("output") ? propPath.slice(7).split(".").filter(Boolean) : propPath.split("."));
   }
   if (path2.startsWith("$var.")) {
     const name = path2.slice(5);
-    if (!ctx.variables.has(name)) {
-      throw new Error(`Variable "${name}" is not defined`);
-    }
+    if (!ctx.variables.has(name)) throw new Error(`Variable "${name}" is not defined`);
     return ctx.variables.get(name);
   }
-  if (path2.startsWith("$input.")) {
-    const key = path2.slice(7);
-    return ctx.input[key];
-  }
+  if (path2.startsWith("$input.")) return ctx.input[path2.slice(7)];
   if (path2 === "true") return true;
   if (path2 === "false") return false;
   if (path2 === "null") return null;
@@ -2028,23 +2023,15 @@ function resolveRef(path2, ctx) {
   return path2;
 }
 function resolveValue(v, ctx) {
-  if (typeof v === "string" && v.startsWith("$")) {
-    return resolveRef(v, ctx);
-  }
-  if (Array.isArray(v)) {
-    return v.map((item) => resolveValue(item, ctx));
-  }
+  if (typeof v === "string" && v.startsWith("$")) return resolveRef(v, ctx);
+  if (Array.isArray(v)) return v.map((item) => resolveValue(item, ctx));
   if (typeof v === "object" && v !== null) {
     const result = {};
-    for (const [k, val] of Object.entries(v)) {
-      result[k] = resolveValue(val, ctx);
-    }
+    for (const [k, val] of Object.entries(v)) result[k] = resolveValue(val, ctx);
     return result;
   }
   return v;
 }
-
-// workflow/nodes.ts
 function evaluateExpression(expr, ctx) {
   const operators = [
     { op: "===", fn: (a, b) => a === b },
@@ -2074,19 +2061,13 @@ function evaluateExpression(expr, ctx) {
       bestFn = fn;
     }
   }
-  function resolveOperand(raw) {
-    const trimmed2 = raw.trim();
-    if (/^[\d.]+$/.test(trimmed2)) return Number(trimmed2);
-    const subIdx = operators.findIndex(({ op }) => trimmed2.includes(op));
-    if (subIdx !== -1) return evaluateExpression(trimmed2, ctx);
-    return resolveValue(trimmed2, ctx);
-  }
   if (bestIdx > 0 && bestOp && bestFn) {
-    const leftRaw = expr.slice(0, bestIdx).trim();
-    const rightRaw = expr.slice(bestIdx + bestOp.length).trim();
-    const left = resolveOperand(leftRaw);
-    const right = resolveOperand(rightRaw);
-    return bestFn(left, right);
+    const left = expr.slice(0, bestIdx).trim();
+    const right = expr.slice(bestIdx + bestOp.length).trim();
+    const isExpr = (s) => /[+\-*/%&|><=!]/.test(s) && !/^[\d.]+$/.test(s);
+    const lv = isExpr(left) ? evaluateExpression(left, ctx) : /^[\d.]+$/.test(left) ? Number(left) : resolveValue(left, ctx);
+    const rv = isExpr(right) ? evaluateExpression(right, ctx) : /^[\d.]+$/.test(right) ? Number(right) : resolveValue(right, ctx);
+    return bestFn(lv, rv);
   }
   const trimmed = expr.trim();
   if (trimmed === "true") return true;
@@ -2096,466 +2077,448 @@ function evaluateExpression(expr, ctx) {
   if (!isNaN(num) && trimmed !== "") return num;
   return resolveValue(expr, ctx);
 }
-async function executeEval(node, ctx) {
-  const expression = node.input.expression;
-  if (!expression) throw new Error('eval node requires "expression" field');
-  const result = evaluateExpression(expression, ctx);
-  return { result };
-}
-async function executeSet(node, ctx) {
-  const name = node.input.name;
-  const value = node.input.value;
-  if (!name) throw new Error('set node requires "name" field');
-  let resolved;
-  if (typeof value === "string") {
-    resolved = evaluateExpression(value, ctx);
-  } else {
-    resolved = resolveValue(value ?? null, ctx);
-  }
-  ctx.variables.set(name, resolved);
-  return resolved;
-}
-async function executeGet(node, ctx) {
-  const name = node.input.name;
-  if (!name) throw new Error('get node requires "name" field');
-  if (!ctx.variables.has(name)) {
-    throw new Error(`Variable "${name}" is not defined`);
-  }
-  return ctx.variables.get(name);
-}
-async function executeIf(node, ctx) {
-  const conditions = node.conditions ?? [];
-  for (const condition of conditions) {
-    const test = typeof condition.test === "string" ? Boolean(resolveValue(condition.test, ctx)) : condition.test;
-    if (test && condition.body) {
-      let lastOutput = void 0;
-      for (const bodyNode of condition.body) {
-        lastOutput = await executeNode(bodyNode, ctx);
-      }
-      return lastOutput;
+async function executeNode(node, ctx) {
+  const { tool: nodeType, input, conditions, body } = node;
+  ctx.stepCount++;
+  if (ctx.stepCount > ctx.maxSteps) throw new Error(`Step limit exceeded (${ctx.maxSteps})`);
+  switch (nodeType) {
+    case "eval": {
+      const expression = input.expression;
+      if (!expression) throw new Error('eval node requires "expression"');
+      return { result: evaluateExpression(expression, ctx) };
+    }
+    case "set": {
+      const name = input.name;
+      if (!name) throw new Error('set node requires "name"');
+      const value = typeof input.value === "string" ? evaluateExpression(input.value, ctx) : resolveValue(input.value, ctx);
+      ctx.variables.set(name, value);
+      return value;
+    }
+    case "get": {
+      const name = input.name;
+      if (!name) throw new Error('get node requires "name"');
+      if (!ctx.variables.has(name)) throw new Error(`Variable "${name}" is not defined`);
+      return ctx.variables.get(name);
+    }
+    case "if": {
+      for (const c of conditions ?? []) {
+        const test = typeof c.test === "string" ? Boolean(resolveValue(c.test, ctx)) : c.test;
+        if (test && c.body) {
+          let last;
+          for (const n of c.body) {
+            last = await executeNode(n, ctx);
+            ctx.nodeOutputs.set(n.id, last);
+          }
+          return last;
+        }
+      }
+      return void 0;
     }
-  }
-  return void 0;
-}
-async function executeWhile(node, ctx) {
-  const conditionExpr = node.input.condition;
-  if (!conditionExpr) throw new Error('while node requires "condition" field');
-  let lastOutput = void 0;
-  let iterations = 0;
-  const maxIterations = 1e3;
-  while (iterations < maxIterations) {
-    iterations++;
-    ctx.stepCount++;
-    if (ctx.stepCount > ctx.maxSteps) {
-      throw new Error(`Step limit exceeded (${ctx.maxSteps})`);
-    }
-    const condition = Boolean(evaluateExpression(conditionExpr, ctx));
-    if (!condition) break;
-    for (const bodyNode of node.body ?? []) {
-      lastOutput = await executeNode(bodyNode, ctx);
-    }
-  }
-  return lastOutput;
-}
-async function executeCall(node, ctx) {
-  const toolName = node.input.tool;
-  const args = node.input.args ?? {};
-  if (toolName && ctx.toolRegistry.has(toolName)) {
-    const tool12 = ctx.toolRegistry.get(toolName);
-    const resolvedInput = resolveValue(args, ctx);
-    const parsed = tool12.inputSchema.parse(resolvedInput);
-    return tool12.execute(parsed, {
-      nodeId: node.id,
-      workflowId: ctx.workflowId,
-      onStream: async (event) => {
-        if (ctx.sseManager && ctx.workflowId) {
-          ctx.sseManager.send(ctx.workflowId, { event: "llm-stream", data: { nodeId: node.id, ...event } });
+    case "while": {
+      const conditionExpr = input.condition;
+      if (!conditionExpr) throw new Error('while node requires "condition"');
+      let last;
+      let iters = 0;
+      while (iters < 1e3) {
+        iters++;
+        ctx.stepCount++;
+        if (ctx.stepCount > ctx.maxSteps) throw new Error(`Step limit exceeded`);
+        if (!Boolean(evaluateExpression(conditionExpr, ctx))) break;
+        for (const n of body ?? []) {
+          last = await executeNode(n, ctx);
+          ctx.nodeOutputs.set(n.id, last);
         }
       }
-    });
-  }
-  const functionName = node.input.function;
-  if (functionName && ctx.functions[functionName]) {
-    const fn = ctx.functions[functionName];
-    const prevFunctions = ctx.functions;
-    const prevInput = ctx.input;
-    ctx.input = resolveValue(args, ctx);
-    let lastOutput = void 0;
-    for (const bodyNode of fn.workflow.nodes) {
-      lastOutput = await executeNode(bodyNode, ctx);
-    }
-    ctx.input = prevInput;
-    return lastOutput;
-  }
-  throw new Error(`call node: tool "${toolName ?? functionName}" not found`);
-}
-async function executeHttp(node, ctx) {
-  const input = resolveValue(node.input, ctx);
-  const url = input.url;
-  if (!url) throw new Error('http node requires "url" field');
-  const controller = new AbortController();
-  const timeout = input.timeout ?? 3e4;
-  const timer = setTimeout(() => controller.abort(), timeout);
-  try {
-    const fetchInit = {
-      method: input.method ?? "GET",
-      headers: input.headers ?? {},
-      signal: controller.signal
-    };
-    if (input.body && fetchInit.method !== "GET") {
-      fetchInit.body = JSON.stringify(input.body);
+      return last;
     }
-    const response = await fetch(url, fetchInit);
-    const contentType = response.headers.get("content-type") ?? "";
-    const body = contentType.includes("application/json") ? await response.json() : await response.text();
-    return {
-      status: response.status,
-      statusText: response.statusText,
-      headers: Object.fromEntries(response.headers.entries()),
-      body
-    };
-  } finally {
-    clearTimeout(timer);
-  }
-}
-var executors = {
-  eval: executeEval,
-  set: executeSet,
-  get: executeGet,
-  if: executeIf,
-  while: executeWhile,
-  call: executeCall,
-  http: executeHttp
-};
-async function executeNode(node, ctx) {
-  const executor = executors[node.tool];
-  if (!executor) {
-    throw new Error(`Unknown node type: "${node.tool}"`);
+    case "call": {
+      const toolName = input.tool;
+      const args = resolveValue(input.args ?? {}, ctx);
+      if (ctx.toolRegistry.has(toolName)) {
+        const t = ctx.toolRegistry.get(toolName);
+        const parsed = t.parameters?.parse ? t.parameters.parse(args) : args;
+        return await t.execute(parsed, { toolCallId: node.id });
+      }
+      throw new Error(`call node: tool "${toolName}" not found`);
+    }
+    case "http": {
+      const opts = resolveValue(input, ctx);
+      const url = opts.url;
+      if (!url) throw new Error('http node requires "url"');
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), opts.timeout ?? 3e4);
+      try {
+        const res = await fetch(url, {
+          method: opts.method ?? "GET",
+          headers: opts.headers ?? {},
+          body: opts.method !== "GET" ? JSON.stringify(opts.body) : void 0,
+          signal: controller.signal
+        });
+        const ct = res.headers.get("content-type") ?? "";
+        return { status: res.status, body: ct.includes("json") ? await res.json() : await res.text() };
+      } finally {
+        clearTimeout(timer);
+      }
+    }
+    default:
+      throw new Error(`Unknown node type: "${nodeType}"`);
   }
-  return executor(node, ctx);
 }
-
-// workflow/llm.ts
-function buildToolsDescription(tools) {
-  return Object.entries(tools).map(([key, t]) => {
-    const name = t.name || key;
-    const schema = t.inputSchema;
-    return `- ${name}: ${t.description}
-  Input schema: describe as JSON object fields`;
-  }).join("\n");
-}
-var SYSTEM_PROMPT_TEMPLATE = `You are a workflow generator. Given a user goal and available tools, output a workflow JSON.
-
-Available tools:
-{{TOOLS}}
-
-Workflow format:
-{
-  "name": "workflow name",
-  "nodes": [
-    {
-      "id": "step1",
-      "tool": "set",
-      "input": { "name": "varName", "value": "initialValue" }
-    },
-    {
-      "id": "step2",
-      "tool": "call",
-      "input": { "tool": "toolName", "args": { "param1": "$var.varName" } }
-    },
-    {
-      "id": "step3",
-      "tool": "if",
-      "input": {},
-      "conditions": [
-        { "test": "$nodes.step2.output.someField", "body": [
-          { "id": "step4", "tool": "call", "input": { "tool": "toolName", "args": {} } }
-        ]}
-      ]
+function runWorkflow(opts = {}) {
+  const toolRegistry = /* @__PURE__ */ new Map();
+  if (opts.tools) {
+    for (const [key, t] of Object.entries(opts.tools)) {
+      toolRegistry.set(key, t);
+    }
+  }
+  return tool({
+    description: "Execute a multi-step workflow. Supports eval, set, get, if, while, call, http nodes. Use $var.x for variables, $nodes.id.output for previous node results, $input.x for input parameters. Call nodes invoke registered tools.",
+    inputSchema: z.object({
+      goal: z.string().describe("What the workflow should accomplish"),
+      nodes: z.array(z.object({
+        id: z.string(),
+        tool: z.string(),
+        input: z.record(z.string(), z.unknown()).optional(),
+        conditions: z.array(z.object({ test: z.any(), body: z.any() })).optional(),
+        body: z.array(z.any()).optional()
+      })).optional().describe("Workflow nodes. Skip this and provide model for LLM to generate from goal.")
+    }),
+    execute: async (input) => {
+      let nodes;
+      if (input.nodes && input.nodes.length > 0) {
+        nodes = input.nodes;
+      } else if (opts.model) {
+        const toolsDesc = Object.entries(opts.tools ?? {}).map(([k, t]) => `- ${k}: ${t.description}`).join("\n");
+        const result = await generateText({
+          model: opts.model,
+          system: [
+            "You are a workflow generator. Given a user goal and available tools, output a workflow JSON.",
+            "",
+            "Available tools:",
+            toolsDesc,
+            "",
+            "Node types: eval (expression), set (variable), get (variable), if (condition), while (loop), call (tool), http (request).",
+            "Reference syntax: $var.name, $nodes.id.output, $nodes.id.output.field, $input.field",
+            "Output ONLY valid JSON. No explanation, no markdown."
+          ].filter(Boolean).join("\n"),
+          messages: [{ role: "user", content: input.goal }]
+        });
+        const text2 = result.text.trim();
+        const jsonStart = text2.indexOf("{");
+        const jsonEnd = text2.lastIndexOf("}");
+        if (jsonStart === -1 || jsonEnd === -1) throw new Error("LLM did not return valid JSON");
+        const parsed = JSON.parse(text2.slice(jsonStart, jsonEnd + 1));
+        nodes = parsed.nodes ?? parsed.workflow?.nodes ?? [];
+        if (!Array.isArray(nodes)) throw new Error("Generated workflow has no nodes array");
+      } else {
+        throw new Error('Provide either "nodes" or a "model" to generate the workflow from "goal"');
+      }
+      const ctx = {
+        variables: /* @__PURE__ */ new Map(),
+        nodeOutputs: /* @__PURE__ */ new Map(),
+        stepCount: 0,
+        maxSteps: opts.maxSteps ?? 200,
+        toolRegistry
+      };
+      let lastOutput;
+      for (const n of nodes) {
+        const output = await executeNode(n, ctx);
+        ctx.nodeOutputs.set(n.id, output);
+        lastOutput = output;
+      }
+      return { result: lastOutput, nodeOutputs: Object.fromEntries(ctx.nodeOutputs) };
     }
-  ]
+  });
 }
 
-Node types:
-- eval: evaluate an expression. input: { expression: "..." }
-- set: assign a variable. input: { name, value }
-- get: read a variable. input: { name }
-- if: conditional branch. input: {}, conditions: [{ test, body }]
-- while: loop. input: { condition }, body: [nodes]
-- call: call a registered tool. input: { tool, args }
-- http: HTTP request. input: { url, method?, headers?, body? }
-
-Reference syntax:
-- $var.name - read a variable
-- $nodes.id.output - output of a previous node
-- $nodes.id.output.field - specific field of a node's output
-- $input.field - workflow input parameter
+// postgres/client.ts
+import postgresFactory from "postgres";
 
-Output ONLY valid JSON. No explanation, no markdown.`;
-async function generateWorkflow(goal, tools, generateFn) {
-  const toolsDesc = buildToolsDescription(tools);
-  const system = SYSTEM_PROMPT_TEMPLATE.replace("{{TOOLS}}", toolsDesc);
-  const result = await generateFn({
-    system,
-    messages: [{ role: "user", content: goal }]
-  });
-  const text2 = result.text.trim();
-  const jsonStart = text2.indexOf("{");
-  const jsonEnd = text2.lastIndexOf("}");
-  if (jsonStart === -1 || jsonEnd === -1) {
-    throw new Error(`LLM output is not valid JSON: ${text2.slice(0, 200)}`);
-  }
-  const jsonStr = text2.slice(jsonStart, jsonEnd + 1);
-  try {
-    const workflow2 = JSON.parse(jsonStr);
-    if (!workflow2.nodes || !Array.isArray(workflow2.nodes)) {
-      throw new Error("Generated workflow has no nodes array");
-    }
-    return workflow2;
-  } catch (err) {
-    if (err instanceof SyntaxError) {
-      throw new Error(`Failed to parse LLM output as JSON: ${err.message}`);
+// postgres/schema/sql.ts
+var SQL = class {
+  strings;
+  values;
+  constructor(strings, values) {
+    this.strings = strings;
+    this.values = values;
+  }
+  toSQL() {
+    let result = "";
+    for (let i = 0; i < this.strings.length; i++) {
+      result += this.strings[i];
+      if (i < this.values.length) {
+        result += String(this.values[i]);
+      }
     }
-    throw err;
+    return result;
   }
+};
+function sql(strings, ...values) {
+  return new SQL(strings, values);
 }
 
-// workflow/engine.ts
-import { generateText } from "ai";
-function createWorkflowEngine(options) {
-  const toolRegistry = /* @__PURE__ */ new Map();
-  for (const [key, t] of Object.entries(options.tools)) {
-    t.name = t.name || key;
-    toolRegistry.set(t.name, t);
-  }
-  const states = /* @__PURE__ */ new Map();
-  async function execute(workflow2, opts) {
-    const ctx = {
-      variables: /* @__PURE__ */ new Map(),
-      nodeOutputs: /* @__PURE__ */ new Map(),
-      functions: workflow2.functions ?? {},
-      stepCount: 0,
-      maxSteps: opts?.maxSteps ?? 1e3,
-      input: opts?.initialInput ?? {},
-      toolRegistry,
-      sseManager: options.sseManager,
-      workflowId: opts?.workflowId
-    };
-    let lastOutput = void 0;
-    for (const node of workflow2.nodes) {
-      ctx.stepCount++;
-      if (ctx.stepCount > ctx.maxSteps) {
-        throw new Error(`Step limit exceeded (${ctx.maxSteps})`);
-      }
-      options.sseManager?.send(ctx.workflowId ?? "", { event: "node-start", data: { nodeId: node.id, tool: node.tool, input: node.input } });
-      const output = await executeNode(node, ctx);
-      ctx.nodeOutputs.set(node.id, output);
-      lastOutput = output;
-      options.sseManager?.send(ctx.workflowId ?? "", { event: "node-end", data: { nodeId: node.id, output } });
-    }
-    return lastOutput;
-  }
-  async function runAsync(workflowId, workflow2, opts) {
-    const state = {
-      workflowId,
-      status: "running",
-      goal: workflow2.name ?? "",
-      startTime: Date.now()
-    };
-    states.set(workflowId, state);
-    const sse = options.sseManager;
-    sse?.send(workflowId, { event: "workflow-start", data: { workflowId, goal: state.goal } });
-    try {
-      const result = await execute(workflow2, { ...opts, workflowId });
-      state.status = "completed";
-      state.result = result;
-      state.endTime = Date.now();
-      sse?.send(workflowId, { event: "complete", data: { result, duration: state.endTime - state.startTime } });
-    } catch (err) {
-      state.status = "error";
-      state.error = err instanceof Error ? err.message : String(err);
-      state.endTime = Date.now();
-      sse?.send(workflowId, { event: "error", data: { error: state.error } });
-    } finally {
-      sse?.close(workflowId);
-    }
+// postgres/schema/columns.ts
+var ColumnBuilder = class {
+  name;
+  sqlType;
+  isPrimaryKey = false;
+  isNullable = true;
+  isUnique = false;
+  isAutoGenerate = false;
+  defaultExpr = null;
+  ref = null;
+  constructor(name, sqlType) {
+    this.name = name;
+    this.sqlType = sqlType;
+  }
+  primaryKey() {
+    this.isPrimaryKey = true;
+    this.isNullable = false;
+    return this;
   }
-  async function generateWorkflow2(goal) {
-    if (!options.model) {
-      throw new Error('LLM model is required for generateWorkflow. Pass "model" to createWorkflowEngine.');
-    }
-    return generateWorkflow(goal, options.tools, async (prompt) => {
-      const result = await generateText({
-        model: options.model,
-        system: prompt.system,
-        messages: prompt.messages
-      });
-      return { text: result.text };
-    });
+  notNull() {
+    this.isNullable = false;
+    return this;
   }
-  return {
-    execute,
-    runAsync,
-    generateWorkflow: generateWorkflow2,
-    getState(workflowId) {
-      return states.get(workflowId);
+  nullable() {
+    this.isNullable = true;
+    return this;
+  }
+  default(expr) {
+    if (expr instanceof SQL) {
+      this.defaultExpr = expr.toSQL();
+    } else if (typeof expr === "string") {
+      this.defaultExpr = `'${expr.replace(/'/g, "''")}'`;
+    } else {
+      this.defaultExpr = String(expr);
     }
-  };
+    return this;
+  }
+  unique() {
+    this.isUnique = true;
+    return this;
+  }
+  references(table, column = "id", onDelete) {
+    this.ref = { table, column, onDelete };
+    return this;
+  }
+};
+function col(name, sqlType) {
+  return new ColumnBuilder(name, sqlType);
 }
-
-// sse.ts
-var encoder = new TextEncoder();
-function formatSSE(event, data) {
-  return `event: ${event}
-data: ${JSON.stringify(data)}
-
-`;
+function serial(name) {
+  const c = col(name, "SERIAL");
+  c.isAutoGenerate = true;
+  return c;
 }
-function formatSSEData(data) {
-  return `data: ${JSON.stringify(data)}
-
-`;
+function uuid(name) {
+  return col(name, "UUID");
 }
-function createSSEStream(iterable, opts) {
-  return new Response(
-    new ReadableStream({
-      async start(controller) {
-        try {
-          for await (const event of iterable) {
-            const text2 = event.type ? formatSSE(event.type, event) : formatSSEData(event);
-            controller.enqueue(encoder.encode(text2));
-          }
-        } catch (e) {
-          if (e.name !== "AbortError") {
-            controller.enqueue(
-              encoder.encode(formatSSE("error", { error: e.message }))
-            );
-          }
-        } finally {
-          controller.close();
-        }
-      }
-    }),
-    {
-      status: opts?.status ?? 200,
-      headers: {
-        "Content-Type": "text/event-stream",
-        "Cache-Control": "no-cache",
-        Connection: "keep-alive",
-        ...opts?.headers
-      }
-    }
-  );
+function text(name) {
+  return col(name, "TEXT");
+}
+function integer(name) {
+  return col(name, "INTEGER");
+}
+function boolean_(name) {
+  return col(name, "BOOLEAN");
+}
+function timestamptz(name) {
+  return col(name, "TIMESTAMPTZ");
+}
+function jsonb(name) {
+  return col(name, "JSONB");
+}
+function textArray(name) {
+  return col(name, "TEXT[]");
+}
+function vector(name, dims) {
+  return col(name, `vector(${dims})`);
+}
+function toDDL(col2) {
+  const parts = [`"${col2.name}"`, col2.sqlType];
+  if (col2.isPrimaryKey) parts.push("PRIMARY KEY");
+  if (!col2.isPrimaryKey && !col2.isNullable) parts.push("NOT NULL");
+  if (col2.isUnique) parts.push("UNIQUE");
+  if (col2.defaultExpr) parts.push(`DEFAULT ${col2.defaultExpr}`);
+  if (col2.ref) {
+    parts.push(`REFERENCES "${col2.ref.table}"("${col2.ref.column}")`);
+    if (col2.ref.onDelete) parts.push(`ON DELETE ${col2.ref.onDelete.toUpperCase()}`);
+  }
+  return parts.join(" ");
 }
 
-// workflow/sse.ts
-function createSSEManager() {
-  const streams = /* @__PURE__ */ new Map();
-  const encoder2 = new TextEncoder();
-  function createStream(workflowId) {
-    const state = {
-      controller: null,
-      encoder: encoder2,
-      closed: false,
-      buffer: []
-    };
-    const stream = new ReadableStream({
-      start(controller) {
-        state.controller = controller;
-        streams.set(workflowId, state);
-        for (const chunk of state.buffer) {
-          try {
-            controller.enqueue(chunk);
-          } catch {
-            break;
-          }
-        }
-        state.buffer = [];
-      },
-      cancel() {
-        state.closed = true;
-        streams.delete(workflowId);
-      }
-    });
-    return stream;
+// postgres/schema/table.ts
+var Table = class {
+  tableName;
+  columns;
+  colEntries;
+  constructor(tableName, builders) {
+    this.tableName = tableName;
+    this.columns = Object.values(builders);
+    this.colEntries = Object.entries(builders).map(([prop, col2]) => ({
+      prop,
+      db: col2.name,
+      auto: col2.isAutoGenerate
+    }));
   }
-  function send(workflowId, event) {
-    const state = streams.get(workflowId);
-    if (!state || state.closed) return;
-    const chunk = encoder2.encode(formatSSE(event.event, event.data));
-    if (state.controller) {
-      try {
-        state.controller.enqueue(chunk);
-      } catch {
-        state.closed = true;
-        streams.delete(workflowId);
+  async create(sql2) {
+    const colDDL = this.columns.map(toDDL);
+    const ddl = `CREATE TABLE IF NOT EXISTS "${this.tableName}" (
+  ${colDDL.join(",\n  ")}
+)`;
+    await sql2.unsafe(ddl);
+  }
+  async drop(sql2, opts) {
+    const cascade = opts?.cascade ? " CASCADE" : "";
+    await sql2.unsafe(`DROP TABLE IF EXISTS "${this.tableName}"${cascade}`);
+  }
+  async createIndex(sql2, columns, opts) {
+    const cols = Array.isArray(columns) ? columns : [columns];
+    const name = `"${this.tableName}_${cols.join("_")}${opts?.unique ? "_uidx" : "_idx"}"`;
+    const unique = opts?.unique ? "UNIQUE" : "";
+    const using = opts?.type ? `USING ${opts.type.toUpperCase()}` : "";
+    const colList = cols.map((c) => opts?.desc ? `"${c}" DESC` : `"${c}"`).join(", ");
+    const operator = opts?.operator ? ` ${opts.operator}` : "";
+    const ddl = `CREATE ${unique} INDEX IF NOT EXISTS ${name} ON "${this.tableName}" ${using} (${colList}${operator})`.replace(/\s+/g, " ");
+    await sql2.unsafe(ddl);
+  }
+  async createUniqueIndex(sql2, columns) {
+    await this.createIndex(sql2, columns, { unique: true });
+  }
+  // --- CRUD ---
+  async insert(sql2, data) {
+    const filtered = {};
+    for (const { prop, db, auto } of this.colEntries) {
+      if (auto) continue;
+      if (prop in data) {
+        filtered[db] = data[prop];
       }
-    } else {
-      state.buffer.push(chunk);
     }
+    const [row] = await sql2`
+      INSERT INTO ${sql2(this.tableName)} ${sql2(filtered)} RETURNING *
+    `;
+    return row;
   }
-  function close(workflowId) {
-    const state = streams.get(workflowId);
-    if (!state) return;
-    state.closed = true;
-    streams.delete(workflowId);
-    try {
-      state.controller?.close();
-    } catch {
-    }
+  async findById(sql2, id2) {
+    const [row] = await sql2`
+      SELECT * FROM ${sql2(this.tableName)}
+      WHERE ${sql2("id")} = ${id2} LIMIT 1
+    `;
+    return row ?? void 0;
   }
-  return { createStream, send, close };
-}
-
-// workflow/route.ts
-import crypto from "node:crypto";
-function workflow(handler) {
-  const r = new Router();
-  const sseManager = createSSEManager();
-  r.get("/:workflowId/events", async (req, ctx) => {
-    const stream = sseManager.createStream(ctx.params.workflowId);
-    return new Response(stream, {
-      headers: {
-        "Content-Type": "text/event-stream",
-        "Cache-Control": "no-cache",
-        "Connection": "keep-alive"
+  async find(sql2, where, opts) {
+    const conditions = [];
+    const values = [];
+    for (const [prop, value] of Object.entries(where || {})) {
+      if (value === void 0) continue;
+      const entry = this.colEntries.find((e) => e.prop === prop);
+      const db = entry ? entry.db : prop;
+      conditions.push(`"${db}" = $${conditions.length + 1}`);
+      values.push(value);
+    }
+    let query = `SELECT * FROM "${this.tableName}"`;
+    if (conditions.length > 0) query += ` WHERE ${conditions.join(" AND ")}`;
+    if (opts?.orderBy) {
+      const orders = Object.entries(opts.orderBy).map(([prop, dir]) => {
+        const entry = this.colEntries.find((e) => e.prop === prop);
+        return `"${entry?.db || prop}" ${dir.toUpperCase()}`;
+      }).join(", ");
+      query += ` ORDER BY ${orders}`;
+    }
+    if (opts?.limit) query += ` LIMIT ${opts.limit}`;
+    if (opts?.offset) query += ` OFFSET ${opts.offset}`;
+    if (conditions.length > 0 || opts?.orderBy || opts?.limit !== void 0 || opts?.offset !== void 0) {
+      const rows2 = await sql2.unsafe(query, values);
+      return rows2;
+    }
+    const rows = await sql2`SELECT * FROM ${sql2(this.tableName)}`;
+    return rows;
+  }
+  async update(sql2, where, data) {
+    const sets = [];
+    const setValues = [];
+    for (const { prop, db } of this.colEntries) {
+      if (prop in data && data[prop] !== void 0) {
+        const val = data[prop];
+        if (val instanceof SQL) {
+          sets.push(`"${db}" = ${val.toSQL()}`);
+        } else {
+          sets.push(`"${db}" = $${sets.length + 1}`);
+          setValues.push(val);
+        }
       }
-    });
-  });
-  r.post("/", async (req, ctx) => {
-    const options = await handler(req, ctx);
-    const engine = createWorkflowEngine({
-      tools: options.tools,
-      model: options.model,
-      sseManager: options.stream ? sseManager : void 0
-    });
-    const body = await req.json();
-    let wf;
-    if (body.goal && options.model) {
-      wf = await engine.generateWorkflow(body.goal);
-    } else if (body.workflow) {
-      wf = body.workflow;
-    } else if (body.nodes) {
-      wf = { nodes: body.nodes };
-    } else {
-      return Response.json(
-        { error: 'Provide "goal" (with model) or "workflow"/"nodes"' },
-        { status: 400 }
-      );
     }
-    if (options.stream && sseManager) {
-      const workflowId = crypto.randomUUID();
-      engine.runAsync(workflowId, wf);
-      return Response.json({ workflowId, eventsUrl: `/${workflowId}/events` });
+    const values = [...setValues];
+    const wConditions = [];
+    for (const [prop, value] of Object.entries(where)) {
+      if (value === void 0) continue;
+      const entry = this.colEntries.find((e) => e.prop === prop);
+      const db = entry ? entry.db : prop;
+      wConditions.push(`"${db}" = $${values.length + 1}`);
+      values.push(value);
     }
-    const result = await engine.execute(wf);
-    return Response.json({ workflow: wf, result });
-  });
-  return r;
+    if (sets.length === 0 || wConditions.length === 0) return void 0;
+    const query = `UPDATE "${this.tableName}" SET ${sets.join(", ")} WHERE ${wConditions.join(" AND ")} RETURNING *`;
+    const rows = await sql2.unsafe(query, values);
+    return rows[0] ?? void 0;
+  }
+  async delete(sql2, where) {
+    const conditions = [];
+    const values = [];
+    for (const [prop, value] of Object.entries(where)) {
+      if (value === void 0) continue;
+      const entry = this.colEntries.find((e) => e.prop === prop);
+      const db = entry ? entry.db : prop;
+      conditions.push(`"${db}" = $${conditions.length + 1}`);
+      values.push(value);
+    }
+    if (conditions.length === 0) return false;
+    const query = `DELETE FROM "${this.tableName}" WHERE ${conditions.join(" AND ")} RETURNING 1`;
+    const rows = await sql2.unsafe(query, values);
+    return rows.length > 0;
+  }
+};
+var BoundTable = class {
+  inner;
+  sql;
+  constructor(sql2, tableName, builders) {
+    this.inner = new Table(tableName, builders);
+    this.sql = sql2;
+  }
+  async create() {
+    await this.inner.create(this.sql);
+  }
+  async drop(opts) {
+    await this.inner.drop(this.sql, opts);
+  }
+  async createIndex(columns, opts) {
+    await this.inner.createIndex(this.sql, columns, opts);
+  }
+  async createUniqueIndex(columns) {
+    await this.inner.createUniqueIndex(this.sql, columns);
+  }
+  async insert(data) {
+    return await this.inner.insert(this.sql, data);
+  }
+  async findById(id2) {
+    return await this.inner.findById(this.sql, id2);
+  }
+  async find(where, opts) {
+    return await this.inner.find(this.sql, where, opts);
+  }
+  async update(where, data) {
+    return await this.inner.update(this.sql, where, data);
+  }
+  async delete(where) {
+    return await this.inner.delete(this.sql, where);
+  }
+};
+function pgTable(tableName, builders) {
+  return new Table(tableName, builders);
 }
 
 // postgres/client.ts
-import postgresFactory from "postgres";
 function postgres(opts) {
   const options = typeof opts === "string" ? { connection: opts } : opts ?? {};
   const connection = options.connection ?? process.env.DATABASE_URL;
@@ -2581,6 +2544,9 @@ function postgres(opts) {
     return next(req, ctx);
   });
   mw.sql = sql2;
+  mw.table = ((tableName, builders) => {
+    return new BoundTable(sql2, tableName, builders);
+  });
   mw.migrate = async () => {
   };
   mw.transaction = (async (fn) => {
@@ -2608,66 +2574,62 @@ var PgModule = class {
 // user/client.ts
 import { randomBytes, scryptSync, timingSafeEqual } from "node:crypto";
 import jwt2 from "jsonwebtoken";
-import { z } from "zod";
+import { z as z2 } from "zod";
 
 // user/migrate.ts
 async function migrate(opts) {
-  const { pg, usersTable, oauth2 } = opts;
-  await pg.sql.unsafe(`
-    CREATE TABLE IF NOT EXISTS "${usersTable}" (
-      "id" SERIAL PRIMARY KEY,
-      "email" TEXT UNIQUE NOT NULL,
-      "password" TEXT NOT NULL,
-      "name" TEXT NOT NULL,
-      "role" TEXT NOT NULL DEFAULT 'user',
-      "created_at" TIMESTAMPTZ NOT NULL DEFAULT NOW(),
-      "updated_at" TIMESTAMPTZ NOT NULL DEFAULT NOW()
-    )
-  `);
+  const { pg, usersTable: name, oauth2 } = opts;
+  const users = pgTable(name, {
+    id: serial("id").primaryKey(),
+    email: text("email").unique().notNull(),
+    password: text("password").notNull(),
+    name: text("name").notNull(),
+    role: text("role").default("user"),
+    created_at: timestamptz("created_at").default(sql`NOW()`),
+    updated_at: timestamptz("updated_at").default(sql`NOW()`)
+  });
+  await users.create(pg.sql);
   if (!oauth2) return;
-  await pg.sql.unsafe(`
-    CREATE TABLE IF NOT EXISTS "_oauth2_clients" (
-      "id" SERIAL PRIMARY KEY,
-      "name" TEXT NOT NULL,
-      "client_id" TEXT UNIQUE NOT NULL,
-      "client_secret" TEXT NOT NULL,
-      "redirect_uris" TEXT[] NOT NULL,
-      "scopes" TEXT DEFAULT '',
-      "created_at" TIMESTAMPTZ NOT NULL DEFAULT NOW()
-    )
-  `);
-  await pg.sql.unsafe(`
-    CREATE TABLE IF NOT EXISTS "_oauth2_codes" (
-      "id" SERIAL PRIMARY KEY,
-      "code" TEXT UNIQUE NOT NULL,
-      "client_id" TEXT NOT NULL,
-      "user_id" INTEGER NOT NULL REFERENCES "${usersTable}"("id"),
-      "redirect_uri" TEXT NOT NULL,
-      "code_challenge" TEXT,
-      "code_challenge_method" TEXT,
-      "scope" TEXT,
-      "expires_at" TIMESTAMPTZ NOT NULL,
-      "used" BOOLEAN NOT NULL DEFAULT FALSE
-    )
-  `);
-  await pg.sql.unsafe(`
-    CREATE TABLE IF NOT EXISTS "_oauth2_tokens" (
-      "id" SERIAL PRIMARY KEY,
-      "token" TEXT UNIQUE NOT NULL,
-      "client_id" TEXT NOT NULL,
-      "user_id" INTEGER REFERENCES "${usersTable}"("id"),
-      "scope" TEXT,
-      "expires_at" TIMESTAMPTZ NOT NULL,
-      "revoked" BOOLEAN NOT NULL DEFAULT FALSE
-    )
-  `);
+  const clients2 = pgTable("_oauth2_clients", {
+    id: serial("id").primaryKey(),
+    name: text("name").notNull(),
+    client_id: text("client_id").unique().notNull(),
+    client_secret: text("client_secret").notNull(),
+    redirect_uris: textArray("redirect_uris").notNull(),
+    scopes: text("scopes").default(""),
+    created_at: timestamptz("created_at").default(sql`NOW()`)
+  });
+  await clients2.create(pg.sql);
+  const codes = pgTable("_oauth2_codes", {
+    id: serial("id").primaryKey(),
+    code: text("code").unique().notNull(),
+    client_id: text("client_id").notNull(),
+    user_id: integer("user_id").notNull().references(name, "id"),
+    redirect_uri: text("redirect_uri").notNull(),
+    code_challenge: text("code_challenge"),
+    code_challenge_method: text("code_challenge_method"),
+    scope: text("scope"),
+    expires_at: timestamptz("expires_at").notNull(),
+    used: boolean_("used").default(false)
+  });
+  await codes.create(pg.sql);
+  const tokens = pgTable("_oauth2_tokens", {
+    id: serial("id").primaryKey(),
+    token: text("token").unique().notNull(),
+    client_id: text("client_id").notNull(),
+    user_id: integer("user_id").references(name, "id"),
+    scope: text("scope"),
+    expires_at: timestamptz("expires_at").notNull(),
+    revoked: boolean_("revoked").default(false)
+  });
+  await tokens.create(pg.sql);
 }
 
 // user/oauth2.ts
-import crypto2 from "node:crypto";
+import crypto from "node:crypto";
 import jwt from "jsonwebtoken";
 function createOAuth2Server(deps) {
-  const { pg, usersTable, jwtSecret, expiresIn } = deps;
+  const { pg, users, jwtSecret, expiresIn } = deps;
   async function getClient(clientId) {
     const [row] = await pg.sql`
       SELECT * FROM "_oauth2_clients" WHERE "client_id" = ${clientId} LIMIT 1
@@ -2683,8 +2645,8 @@ function createOAuth2Server(deps) {
     };
   }
   async function registerClient(data) {
-    const clientId = crypto2.randomUUID();
-    const clientSecret = crypto2.randomBytes(32).toString("hex");
+    const clientId = crypto.randomUUID();
+    const clientSecret = crypto.randomBytes(32).toString("hex");
     const [row] = await pg.sql`
       INSERT INTO "_oauth2_clients" ("name", "client_id", "client_secret", "redirect_uris")
       VALUES (${data.name}, ${clientId}, ${clientSecret}, ${pg.sql.array(data.redirectUris)})
@@ -2832,7 +2794,7 @@ h2{color:#dc2626}.desc{color:#555}</style>
       const loc2 = `${redirectUri}?error=access_denied${state ? `&state=${state}` : ""}`;
       return Response.redirect(loc2, 302);
     }
-    const code = crypto2.randomUUID();
+    const code = crypto.randomUUID();
     const expiresAt = new Date(Date.now() + 10 * 60 * 1e3);
     await pg.sql`
       INSERT INTO "_oauth2_codes" ("code", "client_id", "user_id", "redirect_uri", "code_challenge", "code_challenge_method", "scope", "expires_at")
@@ -2897,16 +2859,14 @@ h2{color:#dc2626}.desc{color:#555}</style>
       if (stored.code_challenge_method === "plain") {
         expected = codeVerifier;
       } else {
-        expected = crypto2.createHash("sha256").update(codeVerifier).digest().toString("base64url");
+        expected = crypto.createHash("sha256").update(codeVerifier).digest().toString("base64url");
       }
       if (expected !== stored.code_challenge) {
         return Response.json({ error: "invalid_grant", error_description: "code_verifier mismatch" }, { status: 400 });
       }
     }
     await pg.sql`UPDATE "_oauth2_codes" SET "used" = TRUE WHERE "id" = ${stored.id}`;
-    const [user2] = await pg.sql`
-      SELECT * FROM ${pg.sql(usersTable)} WHERE "id" = ${stored.user_id} LIMIT 1
-    `;
+    const user2 = await users.findById(stored.user_id);
     if (!user2) {
       return Response.json({ error: "invalid_grant" }, { status: 400 });
     }
@@ -2916,7 +2876,7 @@ h2{color:#dc2626}.desc{color:#555}</style>
       jwtSecret,
       { expiresIn }
     );
-    const refreshToken = crypto2.randomUUID();
+    const refreshToken = crypto.randomUUID();
     const refreshExpires = new Date(Date.now() + 30 * 24 * 60 * 60 * 1e3);
     await pg.sql`
       INSERT INTO "_oauth2_tokens" ("token", "client_id", "user_id", "scope", "expires_at")
@@ -2954,14 +2914,14 @@ h2{color:#dc2626}.desc{color:#555}</style>
 }
 
 // user/client.ts
-var RegisterSchema = z.object({
-  email: z.string().email(),
-  password: z.string().min(6),
-  name: z.string().min(1)
+var RegisterSchema = z2.object({
+  email: z2.string().email(),
+  password: z2.string().min(6),
+  name: z2.string().min(1)
 });
-var LoginSchema = z.object({
-  email: z.string().email(),
-  password: z.string().min(1)
+var LoginSchema = z2.object({
+  email: z2.string().email(),
+  password: z2.string().min(1)
 });
 function hashPassword(password) {
   const salt = randomBytes(16).toString("hex");
@@ -2981,9 +2941,18 @@ function user(options) {
   const expiresIn = options.expiresIn ?? "24h";
   const oauth2Enabled = options.oauth2?.server ?? false;
   const base = new PgModule(pg);
+  const users = pg.table(table, {
+    id: serial("id").primaryKey(),
+    email: text("email").unique().notNull(),
+    password: text("password").notNull(),
+    name: text("name").notNull(),
+    role: text("role").default("user"),
+    created_at: timestamptz("created_at").default(sql`NOW()`),
+    updated_at: timestamptz("updated_at").default(sql`NOW()`)
+  });
   let oauth2 = null;
   if (oauth2Enabled) {
-    oauth2 = createOAuth2Server({ pg, usersTable: table, jwtSecret: secret, expiresIn });
+    oauth2 = createOAuth2Server({ pg, users, jwtSecret: secret, expiresIn });
   }
   async function migrate6() {
     await migrate({ pg, usersTable: table, oauth2: oauth2Enabled });
@@ -3000,12 +2969,11 @@ function user(options) {
     return user2;
   }
   async function findByEmail(email) {
-    const [row] = await pg.sql`SELECT * FROM ${pg.sql(table)} WHERE "email" = ${email} LIMIT 1`;
-    return row;
+    const rows = await users.find({ email });
+    return rows[0];
   }
   async function findById(id2) {
-    const [row] = await pg.sql`SELECT * FROM ${pg.sql(table)} WHERE "id" = ${id2} LIMIT 1`;
-    return row;
+    return await users.findById(id2);
   }
   async function register(data) {
     const { email, password, name } = RegisterSchema.parse(data);
@@ -3016,16 +2984,15 @@ function user(options) {
       throw err;
     }
     const hashed = hashPassword(password);
-    const [row] = await pg.sql`
-      INSERT INTO ${pg.sql(table)} ("email", "password", "name") VALUES (${email}, ${hashed}, ${name}) RETURNING *
-    `;
+    const row = await users.insert({ email, password: hashed, name });
     const userData = row;
     const token = signToken(userData);
     return { user: stripPassword(userData), token };
   }
   async function login(data) {
     const { email, password } = LoginSchema.parse(data);
-    const row = await findByEmail(email);
+    const rows = await users.find({ email });
+    const row = rows[0];
     if (!row) {
       const err = new Error("Invalid email or password");
       err.status = 401;
@@ -3074,7 +3041,7 @@ function user(options) {
         const result = await register(body);
         return Response.json(result, { status: 201 });
       } catch (err) {
-        if (err instanceof z.ZodError) {
+        if (err instanceof z2.ZodError) {
           return Response.json({ error: "Validation failed", issues: err.issues }, { status: 400 });
         }
         const status = err.status ?? 500;
@@ -3089,7 +3056,7 @@ function user(options) {
         res.headers.set("Set-Cookie", `session=${result.token}; HttpOnly; SameSite=Lax; Path=/`);
         return res;
       } catch (err) {
-        if (err instanceof z.ZodError) {
+        if (err instanceof z2.ZodError) {
           return Response.json({ error: "Validation failed", issues: err.issues }, { status: 400 });
         }
         const status = err.status ?? 500;
@@ -3143,7 +3110,7 @@ function redis(opts) {
 
 // queue/index.ts
 import { Redis as IORedis2 } from "ioredis";
-import crypto3 from "node:crypto";
+import crypto2 from "node:crypto";
 function cronNext(expr, from = /* @__PURE__ */ new Date()) {
   const parts = expr.trim().split(/\s+/);
   if (parts.length !== 5) throw new Error(`Invalid cron expression "${expr}": expected 5 fields`);
@@ -3234,7 +3201,7 @@ function queue(opts) {
             if (job.schedule) {
               try {
                 const nextRun = cronNext(job.schedule);
-                const nextJob = { ...job, id: crypto3.randomUUID(), runAt: nextRun, createdAt: Date.now() };
+                const nextJob = { ...job, id: crypto2.randomUUID(), runAt: nextRun, createdAt: Date.now() };
                 redis2.zadd(jobKey, nextRun, JSON.stringify(nextJob)).catch(() => {
                 });
               } catch {
@@ -3252,7 +3219,7 @@ function queue(opts) {
     }
   }
   mw.add = function add(type, payload, opts2) {
-    const id2 = crypto3.randomUUID();
+    const id2 = crypto2.randomUUID();
     let runAt;
     if (opts2?.schedule) {
       runAt = cronNext(opts2.schedule);
@@ -3289,46 +3256,39 @@ function queue(opts) {
 
 // tenant/migrate.ts
 async function migrate2(opts) {
-  const { sql: sql2, usersTable } = opts;
+  const { sql: sql2 } = opts;
   await sql2.unsafe(`CREATE EXTENSION IF NOT EXISTS "vector"`);
-  await sql2.unsafe(`
-    CREATE TABLE IF NOT EXISTS "_tenants" (
-      "id" TEXT PRIMARY KEY DEFAULT gen_random_uuid(),
-      "name" TEXT NOT NULL,
-      "created_at" TIMESTAMPTZ NOT NULL DEFAULT NOW()
-    )
-  `);
-  await sql2.unsafe(`
-    CREATE TABLE IF NOT EXISTS "_tenant_members" (
-      "id" SERIAL PRIMARY KEY,
-      "tenant_id" TEXT NOT NULL REFERENCES "_tenants"("id") ON DELETE CASCADE,
-      "user_id" INTEGER NOT NULL,
-      "role" TEXT NOT NULL DEFAULT 'member',
-      "created_at" TIMESTAMPTZ NOT NULL DEFAULT NOW(),
-      UNIQUE("tenant_id", "user_id")
-    )
-  `);
-  await sql2.unsafe(`
-    CREATE INDEX IF NOT EXISTS "_tenant_members_user_id_idx" ON "_tenant_members" ("user_id")
-  `);
-  await sql2.unsafe(`
-    CREATE TABLE IF NOT EXISTS "_user_tables" (
-      "id" SERIAL PRIMARY KEY,
-      "tenant_id" TEXT NOT NULL REFERENCES "_tenants"("id") ON DELETE CASCADE,
-      "slug" TEXT NOT NULL,
-      "label" TEXT NOT NULL DEFAULT '',
-      "fields" JSONB NOT NULL DEFAULT '[]',
-      "created_at" TIMESTAMPTZ NOT NULL DEFAULT NOW(),
-      UNIQUE("tenant_id", "slug")
-    )
-  `);
-  await sql2.unsafe(`
-    CREATE INDEX IF NOT EXISTS "_user_tables_tenant_id_idx" ON "_user_tables" ("tenant_id")
-  `);
+  const tenants = pgTable("_tenants", {
+    id: text("id").primaryKey().default(sql`gen_random_uuid()`),
+    name: text("name").notNull(),
+    created_at: timestamptz("created_at").notNull().default(sql`NOW()`)
+  });
+  await tenants.create(sql2);
+  const members = pgTable("_tenant_members", {
+    id: serial("id").primaryKey(),
+    tenant_id: text("tenant_id").notNull().references("_tenants", "id", "cascade"),
+    user_id: integer("user_id").notNull(),
+    role: text("role").notNull().default("member"),
+    created_at: timestamptz("created_at").notNull().default(sql`NOW()`)
+  });
+  await members.create(sql2);
+  await members.createIndex(sql2, "user_id");
+  await sql2.unsafe(`CREATE UNIQUE INDEX IF NOT EXISTS "_tenant_members_unique_idx" ON "_tenant_members" ("tenant_id", "user_id")`);
+  const tables = pgTable("_user_tables", {
+    id: serial("id").primaryKey(),
+    tenant_id: text("tenant_id").notNull().references("_tenants", "id", "cascade"),
+    slug: text("slug").notNull(),
+    label: text("label").notNull().default(""),
+    fields: jsonb("fields").notNull().default(sql`'[]'::jsonb`),
+    created_at: timestamptz("created_at").notNull().default(sql`NOW()`)
+  });
+  await tables.create(sql2);
+  await tables.createIndex(sql2, "tenant_id");
+  await sql2.unsafe(`CREATE UNIQUE INDEX IF NOT EXISTS "_user_tables_unique_idx" ON "_user_tables" ("tenant_id", "slug")`);
 }
 
 // tenant/rest.ts
-import { z as z2 } from "zod";
+import { z as z3 } from "zod";
 
 // tenant/utils.ts
 function internalTableName(tenantId, slug) {
@@ -3489,25 +3449,25 @@ function zodType(field) {
   let t;
   switch (field.type) {
     case "integer":
-      t = z2.number().int();
+      t = z3.number().int();
       break;
     case "float":
-      t = z2.number();
+      t = z3.number();
       break;
     case "boolean":
-      t = z2.boolean();
+      t = z3.boolean();
       break;
     case "enum":
-      t = field.options && field.options.length > 0 ? z2.enum(field.options) : z2.string();
+      t = field.options && field.options.length > 0 ? z3.enum(field.options) : z3.string();
       break;
     case "json":
-      t = z2.record(z2.string(), z2.unknown());
+      t = z3.record(z3.string(), z3.unknown());
       break;
     case "vector":
-      t = z2.array(z2.number());
+      t = z3.array(z3.number());
       break;
     default:
-      t = z2.string();
+      t = z3.string();
   }
   if (!field.required) {
     if (field.default !== void 0) {
@@ -3714,7 +3674,7 @@ function buildRouter(sql2, usersTable) {
     for (const f of table.fields) {
       shape[f.name] = zodType(f);
     }
-    const zodSchema = z2.object(shape);
+    const zodSchema = z3.object(shape);
     const parsed = zodSchema.parse(data);
     parsed.tenant_id = ctx.tenant.id;
     delete parsed.id;
@@ -3742,7 +3702,7 @@ function buildRouter(sql2, usersTable) {
     for (const f of table.fields) {
       shape[f.name] = zodType(f);
     }
-    const zodSchema = z2.object(shape).partial();
+    const zodSchema = z3.object(shape).partial();
     const parsed = zodSchema.parse(data);
     delete parsed.id;
     delete parsed.tenant_id;
@@ -3832,7 +3792,7 @@ function buildRouter(sql2, usersTable) {
     for (const f of childTable.fields) {
       shape[f.name] = zodType(f);
     }
-    const zodSchema = z2.object(shape);
+    const zodSchema = z3.object(shape);
     const parsed = zodSchema.parse(body);
     parsed.tenant_id = ctx.tenant.id;
     parsed[relField.name] = parentId;
@@ -4209,38 +4169,32 @@ import { createOpenAI } from "@ai-sdk/openai";
 // agent/migrate.ts
 async function migrate3(opts) {
   const { sql: sql2, embeddingDimension } = opts;
-  await sql2.unsafe(`
-    CREATE TABLE IF NOT EXISTS "_agents" (
-      "id" SERIAL PRIMARY KEY,
-      "tenant_id" TEXT,
-      "name" TEXT NOT NULL,
-      "description" TEXT NOT NULL DEFAULT '',
-      "type" TEXT NOT NULL DEFAULT 'chat',
-      "model" TEXT NOT NULL DEFAULT '',
-      "system_prompt" TEXT NOT NULL DEFAULT '',
-      "owner_id" INTEGER NOT NULL,
-      "active" BOOLEAN NOT NULL DEFAULT true,
-      "created_at" TIMESTAMPTZ NOT NULL DEFAULT NOW(),
-      "updated_at" TIMESTAMPTZ NOT NULL DEFAULT NOW()
-    )
-  `);
-  await sql2.unsafe(`
-    CREATE INDEX IF NOT EXISTS "_agents_tenant_id_idx" ON "_agents" ("tenant_id")
-  `);
-  await sql2.unsafe(`
-    CREATE TABLE IF NOT EXISTS "_knowledge_documents" (
-      "id" SERIAL PRIMARY KEY,
-      "agent_id" INTEGER NOT NULL REFERENCES "_agents"("id") ON DELETE CASCADE,
-      "title" TEXT NOT NULL DEFAULT '',
-      "content" TEXT NOT NULL,
-      "embedding" vector(${embeddingDimension}),
-      "metadata" JSONB NOT NULL DEFAULT '{}',
-      "created_at" TIMESTAMPTZ NOT NULL DEFAULT NOW()
-    )
-  `);
-  await sql2.unsafe(`
-    CREATE INDEX IF NOT EXISTS "_knowledge_documents_agent_id_idx" ON "_knowledge_documents" ("agent_id")
-  `);
+  const agents = pgTable("_agents", {
+    id: serial("id").primaryKey(),
+    tenant_id: text("tenant_id"),
+    name: text("name").notNull(),
+    description: text("description").notNull().default(""),
+    type: text("type").notNull().default("chat"),
+    model: text("model").notNull().default(""),
+    system_prompt: text("system_prompt").notNull().default(""),
+    owner_id: integer("owner_id").notNull(),
+    active: boolean_("active").notNull().default(true),
+    created_at: timestamptz("created_at").notNull().default(sql`NOW()`),
+    updated_at: timestamptz("updated_at").notNull().default(sql`NOW()`)
+  });
+  await agents.create(sql2);
+  await agents.createIndex(sql2, "tenant_id");
+  const docs = pgTable("_knowledge_documents", {
+    id: serial("id").primaryKey(),
+    agent_id: integer("agent_id").notNull().references("_agents", "id", "cascade"),
+    title: text("title").notNull().default(""),
+    content: text("content").notNull(),
+    embedding: vector("embedding", embeddingDimension),
+    metadata: jsonb("metadata").notNull().default(sql`'{}'::jsonb`),
+    created_at: timestamptz("created_at").notNull().default(sql`NOW()`)
+  });
+  await docs.create(sql2);
+  await docs.createIndex(sql2, "agent_id");
 }
 
 // agent/rest.ts
@@ -4350,7 +4304,54 @@ function buildRouter2(deps) {
 
 // agent/run.ts
 import { streamText, generateText as generateText2, embed } from "ai";
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
+
+// sse.ts
+var encoder = new TextEncoder();
+function formatSSE(event, data) {
+  return `event: ${event}
+data: ${JSON.stringify(data)}
+
+`;
+}
+function formatSSEData(data) {
+  return `data: ${JSON.stringify(data)}
+
+`;
+}
+function createSSEStream(iterable, opts) {
+  return new Response(
+    new ReadableStream({
+      async start(controller) {
+        try {
+          for await (const event of iterable) {
+            const text2 = event.type ? formatSSE(event.type, event) : formatSSEData(event);
+            controller.enqueue(encoder.encode(text2));
+          }
+        } catch (e) {
+          if (e.name !== "AbortError") {
+            controller.enqueue(
+              encoder.encode(formatSSE("error", { error: e.message }))
+            );
+          }
+        } finally {
+          controller.close();
+        }
+      }
+    }),
+    {
+      status: opts?.status ?? 200,
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive",
+        ...opts?.headers
+      }
+    }
+  );
+}
+
+// agent/run.ts
 function chunkContent(content, chunkSize = 512, overlap = 64) {
   const paragraphs = content.split(/\n\n+/);
   const chunks = [];
@@ -4390,26 +4391,26 @@ function createRunner(deps) {
     const embedModel = getEmbeddingModel();
     const start = Date.now();
     const hasKB = await hasKnowledgeDocs(sql2, agentId);
-    const messages = params.messages ?? [];
-    if (messages.length === 0) {
-      messages.push({ role: "user", content: params.input });
+    const messages2 = params.messages ?? [];
+    if (messages2.length === 0) {
+      messages2.push({ role: "user", content: params.input });
     }
     const tools = {};
     if (hasKB) {
       tools.searchKnowledge = {
         description: "\u641C\u7D22\u77E5\u8BC6\u5E93\u6587\u6863\u83B7\u53D6\u4E0E\u67E5\u8BE2\u76F8\u5173\u7684\u4FE1\u606F\u3002\u56DE\u7B54\u7528\u6237\u95EE\u9898\u524D\u5FC5\u987B\u5148\u641C\u7D22\u77E5\u8BC6\u5E93\u3002\u5982\u679C\u641C\u7D22\u7ED3\u679C\u4E0D\u8DB3\u4EE5\u56DE\u7B54\uFF0C\u544A\u8BC9\u7528\u6237\u4F60\u4E0D\u77E5\u9053\u3002",
-        parameters: z3.object({
-          query: z3.string().describe("\u641C\u7D22\u5173\u952E\u8BCD\uFF0C\u5E94\u8BE5\u7528\u4E2D\u6587\u63D0\u95EE"),
-          limit: z3.number().default(5).describe("\u8FD4\u56DE\u7ED3\u679C\u6570\u91CF")
+        parameters: z4.object({
+          query: z4.string().describe("\u641C\u7D22\u5173\u952E\u8BCD\uFF0C\u5E94\u8BE5\u7528\u4E2D\u6587\u63D0\u95EE"),
+          limit: z4.number().default(5).describe("\u8FD4\u56DE\u7ED3\u679C\u6570\u91CF")
         }),
         execute: async ({ query, limit }) => {
           return searchKnowledge(sql2, embedModel, agentId, query, limit);
         }
       };
     }
-    if (agent2.type === "workflow" && userTools) {
-      for (const [key, tool12] of Object.entries(userTools)) {
-        tools[key] = tool12;
+    if (agent2.type === "tool-use" && userTools) {
+      for (const [key, tool11] of Object.entries(userTools)) {
+        tools[key] = tool11;
       }
     }
     const system = agent2.system_prompt || void 0;
@@ -4417,7 +4418,7 @@ function createRunner(deps) {
       const result = streamText({
         model,
         system,
-        messages,
+        messages: messages2,
         tools: Object.keys(tools).length > 0 ? tools : void 0
       });
       const fullStream = result.fullStream;
@@ -4440,7 +4441,7 @@ function createRunner(deps) {
       const result = await generateText2({
         model,
         system,
-        messages,
+        messages: messages2,
         tools: Object.keys(tools).length > 0 ? tools : void 0
       });
       return { output: result.text, elapsed: Date.now() - start };
@@ -4511,52 +4512,43 @@ function agent(options) {
 
 // messager/migrate.ts
 async function migrate4(sql2) {
-  await sql2.unsafe(`
-    CREATE TABLE IF NOT EXISTS "_channels" (
-      "id" SERIAL PRIMARY KEY,
-      "tenant_id" TEXT,
-      "name" TEXT NOT NULL DEFAULT '',
-      "type" TEXT NOT NULL DEFAULT 'channel',
-      "created_by" INTEGER NOT NULL,
-      "created_at" TIMESTAMPTZ NOT NULL DEFAULT NOW()
-    )
-  `);
-  await sql2.unsafe(`
-    CREATE INDEX IF NOT EXISTS "_channels_tenant_id_idx" ON "_channels" ("tenant_id")
-  `);
-  await sql2.unsafe(`
-    CREATE TABLE IF NOT EXISTS "_channel_members" (
-      "id" SERIAL PRIMARY KEY,
-      "channel_id" INTEGER NOT NULL REFERENCES "_channels"("id") ON DELETE CASCADE,
-      "member_id" INTEGER NOT NULL,
-      "member_type" TEXT NOT NULL DEFAULT 'user',
-      "role" TEXT NOT NULL DEFAULT 'member',
-      "last_read_id" INTEGER DEFAULT NULL,
-      "last_read_at" TIMESTAMPTZ DEFAULT NULL,
-      UNIQUE("channel_id", "member_id", "member_type")
-    )
-  `);
-  await sql2.unsafe(`
-    CREATE INDEX IF NOT EXISTS "_channel_members_user_idx" ON "_channel_members" ("member_id")
-  `);
-  await sql2.unsafe(`
-    CREATE TABLE IF NOT EXISTS "_messages" (
-      "id" SERIAL PRIMARY KEY,
-      "channel_id" INTEGER NOT NULL REFERENCES "_channels"("id") ON DELETE CASCADE,
-      "sender_id" INTEGER NOT NULL,
-      "sender_type" TEXT NOT NULL DEFAULT 'user',
-      "type" TEXT NOT NULL DEFAULT 'text',
-      "content" TEXT NOT NULL DEFAULT '',
-      "file_url" TEXT DEFAULT NULL,
-      "file_name" TEXT DEFAULT NULL,
-      "file_size" INTEGER DEFAULT NULL,
-      "mime_type" TEXT DEFAULT NULL,
-      "created_at" TIMESTAMPTZ NOT NULL DEFAULT NOW()
-    )
-  `);
-  await sql2.unsafe(`
-    CREATE INDEX IF NOT EXISTS "_messages_channel_created_idx" ON "_messages" ("channel_id", "created_at" DESC)
-  `);
+  const channels2 = pgTable("_channels", {
+    id: serial("id").primaryKey(),
+    tenant_id: text("tenant_id"),
+    name: text("name").notNull().default(""),
+    type: text("type").notNull().default("channel"),
+    created_by: integer("created_by").notNull(),
+    created_at: timestamptz("created_at").notNull().default(sql`NOW()`)
+  });
+  await channels2.create(sql2);
+  await channels2.createIndex(sql2, "tenant_id");
+  const members = pgTable("_channel_members", {
+    id: serial("id").primaryKey(),
+    channel_id: integer("channel_id").notNull().references("_channels", "id", "cascade"),
+    member_id: integer("member_id").notNull(),
+    member_type: text("member_type").notNull().default("user"),
+    role: text("role").notNull().default("member"),
+    last_read_id: integer("last_read_id"),
+    last_read_at: timestamptz("last_read_at")
+  });
+  await members.create(sql2);
+  await members.createIndex(sql2, "member_id");
+  await sql2.unsafe(`CREATE UNIQUE INDEX IF NOT EXISTS "_channel_members_unique_idx" ON "_channel_members" ("channel_id", "member_id", "member_type")`);
+  const messages2 = pgTable("_messages", {
+    id: serial("id").primaryKey(),
+    channel_id: integer("channel_id").notNull().references("_channels", "id", "cascade"),
+    sender_id: integer("sender_id").notNull(),
+    sender_type: text("sender_type").notNull().default("user"),
+    type: text("type").notNull().default("text"),
+    content: text("content").notNull().default(""),
+    file_url: text("file_url"),
+    file_name: text("file_name"),
+    file_size: integer("file_size"),
+    mime_type: text("mime_type"),
+    created_at: timestamptz("created_at").notNull().default(sql`NOW()`)
+  });
+  await messages2.create(sql2);
+  await messages2.createIndex(sql2, ["channel_id", "created_at"], { desc: true });
 }
 
 // messager/ws.ts
@@ -4950,7 +4942,7 @@ function createGateway(config, getPort) {
 }
 
 // deploy/manager.ts
-import crypto4 from "node:crypto";
+import crypto3 from "node:crypto";
 function createManager(config, apps, manager) {
   const router = new Router();
   const auth2 = (req, ctx, next) => {
@@ -4959,7 +4951,7 @@ function createManager(config, apps, manager) {
     const token = header.replace("Bearer ", "");
     const tokenBuf = Buffer.from(token);
     const secretBuf = Buffer.from(config.deployToken);
-    if (tokenBuf.length !== secretBuf.length || !crypto4.timingSafeEqual(tokenBuf, secretBuf)) {
+    if (tokenBuf.length !== secretBuf.length || !crypto3.timingSafeEqual(tokenBuf, secretBuf)) {
       return Response.json({ error: "Unauthorized" }, { status: 401 });
     }
     return next(req, ctx);
@@ -5058,10 +5050,10 @@ function createManager(config, apps, manager) {
     const rawBody = await req.text();
     if (config.webhookSecret) {
       const sig = req.headers.get("x-hub-signature-256") ?? "";
-      const expected = `sha256=${crypto4.createHmac("sha256", config.webhookSecret).update(rawBody).digest("hex")}`;
+      const expected = `sha256=${crypto3.createHmac("sha256", config.webhookSecret).update(rawBody).digest("hex")}`;
       const sigBuf = Buffer.from(sig);
       const expectedBuf = Buffer.from(expected);
-      if (sigBuf.length !== expectedBuf.length || !crypto4.timingSafeEqual(sigBuf, expectedBuf)) {
+      if (sigBuf.length !== expectedBuf.length || !crypto3.timingSafeEqual(sigBuf, expectedBuf)) {
         return Response.json({ error: "invalid signature" }, { status: 401 });
       }
     }
@@ -5114,14 +5106,14 @@ function forkApp(opts) {
   return { child, port: opts.port };
 }
 function stopProcess(mp, timeout = 1e4) {
-  return new Promise((resolve9) => {
+  return new Promise((resolve10) => {
     const timer = setTimeout(() => {
       mp.child.kill("SIGKILL");
-      resolve9();
+      resolve10();
     }, timeout);
     mp.child.on("exit", () => {
       clearTimeout(timer);
-      resolve9();
+      resolve10();
     });
     mp.child.kill("SIGTERM");
   });
@@ -5340,7 +5332,7 @@ async function deploy(config) {
   });
   const portSuffix = config.port !== 80 ? `:${config.port}` : "";
   return {
-    stop: async () => {
+    close: async () => {
       for (const [, app] of apps) {
         if (app.restartTimer) clearTimeout(app.restartTimer);
         if (app.process) {
@@ -5413,47 +5405,63 @@ import { createOpenAI as createOpenAI2 } from "@ai-sdk/openai";
 
 // opencode/migrate.ts
 async function migrate5(sql2) {
-  await sql2.unsafe(`
-    CREATE TABLE IF NOT EXISTS "_opencode_sessions" (
-      "id" UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-      "tenant_id" TEXT,
-      "user_id" INTEGER NOT NULL DEFAULT 0,
-      "title" TEXT,
-      "agent_type" TEXT NOT NULL DEFAULT 'build',
-      "model" TEXT NOT NULL DEFAULT 'deepseek-v4-flash',
-      "system_prompt" TEXT,
-      "workspace" TEXT,
-      "metadata" JSONB NOT NULL DEFAULT '{}',
-      "active" BOOLEAN NOT NULL DEFAULT true,
-      "created_at" TIMESTAMPTZ NOT NULL DEFAULT NOW(),
-      "updated_at" TIMESTAMPTZ NOT NULL DEFAULT NOW()
-    )
-  `);
-  await sql2.unsafe(`
-    CREATE INDEX IF NOT EXISTS "_opencode_sessions_user_idx" ON "_opencode_sessions" ("user_id")
-  `);
-  await sql2.unsafe(`
-    CREATE TABLE IF NOT EXISTS "_opencode_messages" (
-      "id" SERIAL PRIMARY KEY,
-      "session_id" UUID NOT NULL REFERENCES "_opencode_sessions"("id") ON DELETE CASCADE,
-      "role" TEXT NOT NULL,
-      "content" TEXT,
-      "tool_calls" JSONB,
-      "tool_results" JSONB,
-      "tokens_in" INTEGER NOT NULL DEFAULT 0,
-      "tokens_out" INTEGER NOT NULL DEFAULT 0,
-      "created_at" TIMESTAMPTZ NOT NULL DEFAULT NOW()
-    )
-  `);
-  await sql2.unsafe(`
-    CREATE INDEX IF NOT EXISTS "_opencode_messages_session_idx" ON "_opencode_messages" ("session_id", "created_at")
-  `);
+  const sessions2 = pgTable("_opencode_sessions", {
+    id: uuid("id").default(sql`gen_random_uuid()`).primaryKey(),
+    tenant_id: text("tenant_id"),
+    user_id: integer("user_id").default(0),
+    title: text("title"),
+    agent_type: text("agent_type").default("build"),
+    model: text("model").default("deepseek-v4-flash"),
+    system_prompt: text("system_prompt"),
+    workspace: text("workspace"),
+    metadata: jsonb("metadata").default(sql`'{}'::jsonb`),
+    active: boolean_("active").default(true),
+    created_at: timestamptz("created_at").default(sql`NOW()`),
+    updated_at: timestamptz("updated_at").default(sql`NOW()`)
+  });
+  await sessions2.create(sql2);
+  await sessions2.createIndex(sql2, "user_id");
+  const messages2 = pgTable("_opencode_messages", {
+    id: serial("id").primaryKey(),
+    session_id: uuid("session_id").notNull().references("_opencode_sessions", "id", "cascade"),
+    role: text("role").notNull(),
+    content: text("content"),
+    tool_calls: jsonb("tool_calls"),
+    tool_results: jsonb("tool_results"),
+    tokens_in: integer("tokens_in").default(0),
+    tokens_out: integer("tokens_out").default(0),
+    created_at: timestamptz("created_at").default(sql`NOW()`)
+  });
+  await messages2.create(sql2);
+  await messages2.createIndex(sql2, ["session_id", "created_at"]);
 }
 
 // opencode/session.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
 import { join as join3 } from "node:path";
 import { mkdir as mkdir2 } from "node:fs/promises";
+var sessions = pgTable("_opencode_sessions", {
+  id: uuid("id"),
+  user_id: integer("user_id"),
+  title: text("title"),
+  model: text("model"),
+  workspace: text("workspace"),
+  system_prompt: text("system_prompt"),
+  active: boolean_("active"),
+  updated_at: timestamptz("updated_at"),
+  created_at: timestamptz("created_at")
+});
+var messages = pgTable("_opencode_messages", {
+  id: serial("id"),
+  session_id: uuid("session_id"),
+  role: text("role"),
+  content: text("content"),
+  tool_calls: jsonb("tool_calls"),
+  tool_results: jsonb("tool_results"),
+  tokens_in: integer("tokens_in"),
+  tokens_out: integer("tokens_out"),
+  created_at: timestamptz("created_at")
+});
 async function createSession(sql2, opts, cwd, mountPath) {
   const id2 = randomUUID2();
   const ws = computeSessionWorkspace(cwd, mountPath, id2);
@@ -5470,27 +5478,26 @@ function computeSessionWorkspace(cwd, mountPath, sessionId) {
   return join3(cwd, ".sessions", name, sessionId);
 }
 async function getSession(sql2, id2) {
-  const [row] = await sql2`SELECT * FROM "_opencode_sessions" WHERE id = ${id2} AND active = true LIMIT 1`;
-  return row ?? null;
+  const rows = await sessions.find(sql2, { id: id2, active: true });
+  return rows[0] ?? null;
 }
 async function listSessions(sql2, userId) {
+  const opts = { orderBy: { updated_at: "desc" } };
   if (userId !== void 0) {
-    const rows2 = await sql2`SELECT * FROM "_opencode_sessions" WHERE user_id = ${userId} AND active = true ORDER BY updated_at DESC`;
+    const rows2 = await sessions.find(sql2, { user_id: userId, active: true }, opts);
     return rows2;
   }
-  const rows = await sql2`SELECT * FROM "_opencode_sessions" WHERE active = true ORDER BY updated_at DESC`;
+  const rows = await sessions.find(sql2, { active: true }, opts);
   return rows;
 }
 async function deleteSession(sql2, id2) {
-  await sql2`UPDATE "_opencode_sessions" SET active = false, updated_at = NOW() WHERE id = ${id2}`;
+  await sessions.update(sql2, { id: id2 }, { active: false, updated_at: sql`NOW()` });
 }
 async function getHistory(sql2, sessionId, limit = 50) {
-  const rows = await sql2`
-    SELECT * FROM "_opencode_messages"
-    WHERE session_id = ${sessionId}
-    ORDER BY created_at ASC
-    LIMIT ${limit}
-  `;
+  const rows = await messages.find(sql2, { session_id: sessionId }, {
+    orderBy: { created_at: "asc" },
+    limit
+  });
   return rows;
 }
 async function addTextMessage(sql2, sessionId, role, content, tokensIn = 0, tokensOut = 0) {
@@ -5513,7 +5520,7 @@ async function addToolMessages(sql2, sessionId, toolCalls, toolResults) {
 // opencode/run.ts
 import { streamText as streamText2, stepCountIs } from "ai";
 async function* executeGenerator(opts) {
-  const { sessionId, input, model, tools, systemPrompt, messages, sql: sql2, abortSignal } = opts;
+  const { sessionId, input, model, tools, systemPrompt, messages: messages2, sql: sql2, abortSignal } = opts;
   const lastStepToolCalls = [];
   let currentAssistantText = "";
   let currentUsage = { promptTokens: 0, completionTokens: 0, totalTokens: 0 };
@@ -5521,7 +5528,7 @@ async function* executeGenerator(opts) {
     model,
     system: systemPrompt,
     messages: [
-      ...messages.map((m) => {
+      ...messages2.map((m) => {
         if (m.role === "user") return { role: "user", content: m.content ?? "" };
         if (m.role === "assistant") return { role: "assistant", content: m.content ?? "" };
         return { role: "user", content: "" };
@@ -5649,26 +5656,26 @@ function isSkillAllowed(name, perms) {
 }
 
 // opencode/tools/bash.ts
-import { tool as tool3 } from "ai";
-import { z as z4 } from "zod";
+import { tool as tool2 } from "ai";
+import { z as z5 } from "zod";
 import { exec } from "node:child_process";
 function createBashTool(ctx) {
-  return tool3({
+  return tool2({
     description: "Execute a shell command in the workspace directory. Returns stdout, stderr, and exit code.",
-    inputSchema: z4.object({
-      command: z4.string().describe("The shell command to execute"),
-      timeout: z4.number().default(30).describe("Timeout in seconds"),
-      workdir: z4.string().optional().describe("Subdirectory relative to workspace")
+    inputSchema: z5.object({
+      command: z5.string().describe("The shell command to execute"),
+      timeout: z5.number().default(30).describe("Timeout in seconds"),
+      workdir: z5.string().optional().describe("Subdirectory relative to workspace")
     }),
     execute: async ({ command, timeout, workdir }) => {
       if (!isCommandAllowed(command)) {
         return { stdout: "", stderr: "Command denied: potentially dangerous command", exitCode: 1 };
       }
       const cwd = workdir ? `${ctx.workspace}/${workdir}` : ctx.workspace;
-      return new Promise((resolve9) => {
+      return new Promise((resolve10) => {
         const child = exec(command, { cwd, timeout: timeout * 1e3, maxBuffer: 1024 * 1024 }, (error, stdout, stderr) => {
           const truncated = stdout.length > 1e6 || stderr.length > 1e6;
-          resolve9({
+          resolve10({
             stdout: stdout.slice(0, 1e6),
             stderr: stderr.slice(0, 1e6),
             exitCode: error?.code ?? 0,
@@ -5682,17 +5689,17 @@ function createBashTool(ctx) {
 }
 
 // opencode/tools/read.ts
-import { tool as tool4 } from "ai";
-import { z as z5 } from "zod";
+import { tool as tool3 } from "ai";
+import { z as z6 } from "zod";
 import { readFileSync as readFileSync2 } from "node:fs";
 import { resolve as resolve3 } from "node:path";
 function createReadTool(ctx) {
-  return tool4({
+  return tool3({
     description: "Read file contents. Supports offset and limit for reading specific line ranges.",
-    inputSchema: z5.object({
-      path: z5.string().describe("File path relative to workspace"),
-      offset: z5.number().optional().describe("Starting line number (1-indexed)"),
-      limit: z5.number().optional().describe("Number of lines to read")
+    inputSchema: z6.object({
+      path: z6.string().describe("File path relative to workspace"),
+      offset: z6.number().optional().describe("Starting line number (1-indexed)"),
+      limit: z6.number().optional().describe("Number of lines to read")
     }),
     execute: async ({ path: path2, offset, limit }) => {
       const resolved = resolve3(ctx.workspace, path2);
@@ -5724,16 +5731,16 @@ function createReadTool(ctx) {
 }
 
 // opencode/tools/write.ts
-import { tool as tool5 } from "ai";
-import { z as z6 } from "zod";
+import { tool as tool4 } from "ai";
+import { z as z7 } from "zod";
 import { writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "node:fs";
 import { resolve as resolve4, dirname as dirname2 } from "node:path";
 function createWriteTool(ctx) {
-  return tool5({
+  return tool4({
     description: "Create or overwrite a file. Parent directories are created automatically.",
-    inputSchema: z6.object({
-      path: z6.string().describe("File path relative to workspace"),
-      content: z6.string().describe("File content")
+    inputSchema: z7.object({
+      path: z7.string().describe("File path relative to workspace"),
+      content: z7.string().describe("File content")
     }),
     execute: async ({ path: path2, content }) => {
       const resolved = resolve4(ctx.workspace, path2);
@@ -5748,18 +5755,18 @@ function createWriteTool(ctx) {
 }
 
 // opencode/tools/edit.ts
-import { tool as tool6 } from "ai";
-import { z as z7 } from "zod";
+import { tool as tool5 } from "ai";
+import { z as z8 } from "zod";
 import { readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "node:fs";
 import { resolve as resolve5 } from "node:path";
 function createEditTool(ctx) {
-  return tool6({
+  return tool5({
     description: "Perform exact string replacements in a file. If oldString appears multiple times, provide more surrounding context.",
-    inputSchema: z7.object({
-      path: z7.string().describe("File path relative to workspace"),
-      oldString: z7.string().describe("The exact text to replace"),
-      newString: z7.string().describe("The replacement text"),
-      replaceAll: z7.boolean().default(false).describe("Replace all occurrences")
+    inputSchema: z8.object({
+      path: z8.string().describe("File path relative to workspace"),
+      oldString: z8.string().describe("The exact text to replace"),
+      newString: z8.string().describe("The replacement text"),
+      replaceAll: z8.boolean().default(false).describe("Replace all occurrences")
     }),
     execute: async ({ path: path2, oldString, newString, replaceAll }) => {
       const resolved = resolve5(ctx.workspace, path2);
@@ -5792,19 +5799,19 @@ function createEditTool(ctx) {
 }
 
 // opencode/tools/grep.ts
-import { tool as tool7 } from "ai";
-import { z as z8 } from "zod";
+import { tool as tool6 } from "ai";
+import { z as z9 } from "zod";
 import { execSync as execSync2 } from "node:child_process";
 import { resolve as resolve6 } from "node:path";
 import { existsSync as existsSync2 } from "node:fs";
 function createGrepTool(ctx) {
-  return tool7({
+  return tool6({
     description: "Search file contents using regex. Supports file type filtering and context lines.",
-    inputSchema: z8.object({
-      pattern: z8.string().describe("The regex pattern to search for"),
-      include: z8.string().optional().describe('File glob filter (e.g. "*.ts")'),
-      path: z8.string().optional().describe("Subdirectory relative to workspace"),
-      context: z8.number().default(0).describe("Number of context lines before and after each match")
+    inputSchema: z9.object({
+      pattern: z9.string().describe("The regex pattern to search for"),
+      include: z9.string().optional().describe('File glob filter (e.g. "*.ts")'),
+      path: z9.string().optional().describe("Subdirectory relative to workspace"),
+      context: z9.number().default(0).describe("Number of context lines before and after each match")
     }),
     execute: async ({ pattern, include, path: path2, context }) => {
       const searchDir = path2 ? resolve6(ctx.workspace, path2) : ctx.workspace;
@@ -5830,16 +5837,16 @@ function createGrepTool(ctx) {
 }
 
 // opencode/tools/glob.ts
-import { tool as tool8 } from "ai";
-import { z as z9 } from "zod";
+import { tool as tool7 } from "ai";
+import { z as z10 } from "zod";
 import { execSync as execSync3 } from "node:child_process";
 import { resolve as resolve7 } from "node:path";
 function createGlobTool(ctx) {
-  return tool8({
+  return tool7({
     description: "Find files matching a glob pattern.",
-    inputSchema: z9.object({
-      pattern: z9.string().describe('Glob pattern (e.g. "src/**/*.ts")'),
-      path: z9.string().optional().describe("Subdirectory relative to workspace")
+    inputSchema: z10.object({
+      pattern: z10.string().describe('Glob pattern (e.g. "src/**/*.ts")'),
+      path: z10.string().optional().describe("Subdirectory relative to workspace")
     }),
     execute: async ({ pattern, path: path2 }) => {
       const searchDir = path2 ? resolve7(ctx.workspace, path2) : ctx.workspace;
@@ -5858,13 +5865,13 @@ function createGlobTool(ctx) {
 }
 
 // opencode/tools/web.ts
-import { tool as tool9 } from "ai";
-import { z as z10 } from "zod";
+import { tool as tool8 } from "ai";
+import { z as z11 } from "zod";
 function createWebTool(ctx) {
-  return tool9({
+  return tool8({
     description: "Fetch a URL and return the content as text.",
-    inputSchema: z10.object({
-      url: z10.string().describe("The URL to fetch")
+    inputSchema: z11.object({
+      url: z11.string().describe("The URL to fetch")
     }),
     execute: async ({ url }) => {
       try {
@@ -5886,17 +5893,17 @@ function createWebTool(ctx) {
 }
 
 // opencode/tools/question.ts
-import { tool as tool10 } from "ai";
-import { z as z11 } from "zod";
+import { tool as tool9 } from "ai";
+import { z as z12 } from "zod";
 function createQuestionTool(ctx) {
-  return tool10({
+  return tool9({
     description: "Ask the user a question when you need more information to proceed.",
-    inputSchema: z11.object({
-      question: z11.string().describe("The question to ask the user"),
-      options: z11.array(z11.string()).optional().describe("Optional multiple choice options")
+    inputSchema: z12.object({
+      question: z12.string().describe("The question to ask the user"),
+      options: z12.array(z12.string()).optional().describe("Optional multiple choice options")
     }),
     execute: async ({ question, options }, { toolCallId }) => {
-      return new Promise((resolve9, reject) => {
+      return new Promise((resolve10, reject) => {
         const timeout = setTimeout(() => {
           ctx.pendingQuestions.delete(toolCallId);
           reject(new Error("Question timed out"));
@@ -5904,7 +5911,7 @@ function createQuestionTool(ctx) {
         ctx.pendingQuestions.set(toolCallId, {
           resolve: (answer) => {
             clearTimeout(timeout);
-            resolve9(answer);
+            resolve10(answer);
           },
           reject: (err) => {
             clearTimeout(timeout);
@@ -5917,8 +5924,8 @@ function createQuestionTool(ctx) {
 }
 
 // opencode/tools/skill.ts
-import { tool as tool11 } from "ai";
-import { z as z12 } from "zod";
+import { tool as tool10 } from "ai";
+import { z as z13 } from "zod";
 function createSkillTool(ctx) {
   const skills = ctx.skillsRegistry.list();
   const availableList = skills.map(
@@ -5932,10 +5939,10 @@ function createSkillTool(ctx) {
 <available_skills>
 ${availableList}
 </available_skills>` : "No skills available.";
-  return tool11({
+  return tool10({
     description,
-    inputSchema: z12.object({
-      name: z12.string().describe("The name of the skill to load")
+    inputSchema: z13.object({
+      name: z13.string().describe("The name of the skill to load")
     }),
     execute: async ({ name }) => {
       if (!isSkillAllowed(name, ctx.permissions)) {
@@ -6001,15 +6008,15 @@ async function buildRouter4(deps) {
     return Response.json(session, { status: 201 });
   });
   router.get("/sessions", async () => {
-    const sessions = await listSessions(sql2);
-    return Response.json(sessions);
+    const sessions2 = await listSessions(sql2);
+    return Response.json(sessions2);
   });
   router.get("/sessions/:id", async (_req, ctx) => {
     const id2 = ctx.params.id;
     const session = await getSession(sql2, id2);
     if (!session) return new Response("Not Found", { status: 404 });
-    const messages = await getHistory(sql2, id2);
-    return Response.json({ session, messages });
+    const messages2 = await getHistory(sql2, id2);
+    return Response.json({ session, messages: messages2 });
   });
   router.delete("/sessions/:id", async (_req, ctx) => {
     const id2 = ctx.params.id;
@@ -6289,38 +6296,138 @@ async function opencode(options) {
     close: () => base.close()
   };
 }
+
+// health.ts
+function health(options) {
+  const path2 = options?.path ?? "/health";
+  const r = new Router();
+  const handler = async () => {
+    try {
+      await options?.check?.();
+      return new Response("OK", { status: 200 });
+    } catch {
+      return new Response("Service Unavailable", { status: 503 });
+    }
+  };
+  r.get(path2, handler);
+  r.head(path2, handler);
+  return r;
+}
+
+// i18n.ts
+import { readFile as readFile2 } from "node:fs/promises";
+import { existsSync as existsSync3 } from "node:fs";
+import { join as join4, resolve as resolve9 } from "node:path";
+function i18n(options) {
+  const dir = resolve9(options.dir);
+  const defaultLocale = options.defaultLocale ?? "en";
+  const cache = /* @__PURE__ */ new Map();
+  async function load(locale) {
+    const cached = cache.get(locale);
+    if (cached) return cached;
+    const filePath = join4(dir, `${locale}.json`);
+    if (!existsSync3(filePath)) return {};
+    try {
+      const content = await readFile2(filePath, "utf-8");
+      const data = JSON.parse(content);
+      cache.set(locale, data);
+      return data;
+    } catch {
+      return {};
+    }
+  }
+  function detect(req) {
+    const url = new URL(req.url);
+    const fromCookie = extractCookie(req, "locale");
+    if (fromCookie) return fromCookie;
+    const fromHeader = req.headers.get("Accept-Language")?.split(",")[0]?.split("-")[0];
+    if (fromHeader) return fromHeader;
+    return defaultLocale;
+  }
+  function t(localeMsgs, key, params) {
+    let msg = localeMsgs[key];
+    if (msg === void 0) msg = key;
+    if (params) {
+      for (const [k, v] of Object.entries(params)) {
+        msg = msg.replace(`{${k}}`, v);
+      }
+    }
+    return msg;
+  }
+  return async (req, ctx, next) => {
+    const locale = detect(req);
+    const msgs = await load(locale);
+    ctx.locale = locale;
+    ctx.t = (key, params) => t(msgs, key, params);
+    return next(req, ctx);
+  };
+}
+function extractCookie(req, name) {
+  const cookie = req.headers.get("cookie");
+  if (!cookie) return null;
+  for (const part of cookie.split(";")) {
+    const [k, v] = part.trim().split("=");
+    if (k === name && v) return decodeURIComponent(v);
+  }
+  return null;
+}
+
+// mailer.ts
+import { createTransport } from "nodemailer";
+function mailer(options) {
+  const sender = options.send;
+  const from = options.from;
+  let transporter = null;
+  if (!sender && options.transport) {
+    transporter = typeof options.transport === "string" ? createTransport(options.transport) : options.transport;
+  }
+  async function send(opts) {
+    if (sender) {
+      await sender(opts);
+      return;
+    }
+    if (!transporter) {
+      throw new Error("mailer: no transport configured \u2014 provide `transport` or `send` option");
+    }
+    await transporter.sendMail({ ...opts, from: opts.from ?? from });
+  }
+  async function close() {
+    if (transporter) transporter.close();
+  }
+  return { send, close };
+}
 export {
   Router,
   TsxContext,
   agent,
-  ai,
+  aiStream,
   auth,
   compress,
   cors,
-  createSSEManager,
-  createWorkflowEngine,
+  createTestServer,
   defineConfig,
   deleteCookie,
   deploy,
-  generateWorkflow,
   getCookies,
   graphql,
+  health,
+  i18n,
   logger,
+  mailer,
   messager,
   opencode,
   postgres,
   queue,
   rateLimit,
   redis,
+  runWorkflow,
   serve,
   serveStatic,
   setCookie,
   tenant,
-  tool,
   tsx,
   upload,
   useTsx,
   user,
-  validate,
-  workflow
+  validate
 };