npm - weifuwu - Versions diffs - 0.3.0 → 0.5.0 - Mend

weifuwu 0.3.0 → 0.5.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (21) hide show

package/README.md +399 -226
package/dist/ai.d.ts +7 -0
package/dist/graphql.d.ts +12 -0
package/dist/index.d.ts +9 -1
package/dist/index.js +900 -139
package/dist/postgres/client.d.ts +2 -0
package/dist/postgres/index.d.ts +2 -0
package/dist/postgres/migrate.d.ts +3 -0
package/dist/postgres/table.d.ts +4 -0
package/dist/postgres/types.d.ts +51 -0
package/dist/router.d.ts +0 -16
package/dist/workflow/engine.d.ts +7 -0
package/dist/workflow/index.d.ts +8 -0
package/dist/workflow/llm.d.ts +10 -0
package/dist/workflow/nodes.d.ts +10 -0
package/dist/workflow/reference.d.ts +3 -0
package/dist/workflow/route.d.ts +11 -0
package/dist/workflow/sse.d.ts +2 -0
package/dist/workflow/tool.d.ts +8 -0
package/dist/workflow/types.d.ts +86 -0
package/package.json +3 -2

package/dist/index.js CHANGED Viewed

@@ -107,9 +107,6 @@ function serve(handler, options) {
 // router.ts
 import { WebSocketServer } from "ws";
-import { buildSchema, graphql } from "graphql";
-import { makeExecutableSchema } from "@graphql-tools/schema";
-import { streamText } from "ai";
 var createTrieNode = () => ({
   children: /* @__PURE__ */ new Map(),
   handlers: /* @__PURE__ */ new Map(),
@@ -261,47 +258,6 @@ var Router = class _Router {
     if (middlewares.length > 0) node.middlewares = middlewares;
     return this;
   }
-  graphql(path, ...args) {
-    const options = args.pop();
-    const middlewares = args;
-    const schema = typeof options.schema === "string" ? options.resolvers ? makeExecutableSchema({
-      typeDefs: options.schema,
-      resolvers: options.resolvers
-    }) : buildSchema(options.schema) : options.schema;
-    const handler = (req, ctx) => {
-      const url = new URL(req.url);
-      if (options.graphiql && req.method === "GET" && !url.searchParams.has("query")) {
-        return new Response(getGraphiQLHtml(url.pathname), {
-          status: 200,
-          headers: { "Content-Type": "text/html" }
-        });
-      }
-      if (req.method !== "GET" && req.method !== "POST") {
-        return new Response("Not Found", { status: 404 });
-      }
-      const paramsPromise = req.method === "GET" ? Promise.resolve(parseGraphQLParamsFromGet(url)) : parseGraphQLParamsFromPost(req);
-      return paramsPromise.then((params) => {
-        if (!params) {
-          return Response.json(
-            { errors: [{ message: "Missing query" }] },
-            { status: 400 }
-          );
-        }
-        return executeGraphQLQuery(schema, params, options, req, ctx);
-      });
-    };
-    return this.all(path, ...middlewares, handler);
-  }
-  ai(path, ...args) {
-    const handler = args.pop();
-    const middlewares = args;
-    const routeHandler = async (req, ctx) => {
-      const options = await handler(req, ctx);
-      const result = streamText(options);
-      return result.toTextStreamResponse();
-    };
-    return this.post(path, ...middlewares, routeHandler);
-  }
   handler() {
     return (req, ctx) => {
       const url = new URL(req.url);
@@ -506,100 +462,6 @@ function sendHttpResponseOnSocket(socket, response) {
     socket.end();
   });
 }
-function parseGraphQLParamsFromGet(url) {
-  const query = url.searchParams.get("query");
-  if (!query) return null;
-  const variablesStr = url.searchParams.get("variables");
-  let variables = {};
-  if (variablesStr) {
-    try {
-      variables = JSON.parse(variablesStr);
-    } catch {
-      return null;
-    }
-  }
-  return {
-    query,
-    variables,
-    operationName: url.searchParams.get("operationName") || void 0
-  };
-}
-async function parseGraphQLParamsFromPost(req) {
-  try {
-    const body = await req.json();
-    if (!body.query) return null;
-    return {
-      query: body.query,
-      variables: body.variables || {},
-      operationName: body.operationName
-    };
-  } catch {
-    return null;
-  }
-}
-async function executeGraphQLQuery(schema, params, options, req, ctx) {
-  const contextValue = options.context ? await options.context(req, ctx) : ctx;
-  const result = await graphql({
-    schema,
-    source: params.query,
-    rootValue: options.rootValue,
-    contextValue,
-    variableValues: params.variables,
-    operationName: params.operationName
-  });
-  return Response.json(result, { status: result.errors ? 400 : 200 });
-}
-function getGraphiQLHtml(endpoint) {
-  return `<!doctype html>
-<html lang="en">
-  <head>
-    <meta charset="UTF-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>GraphiQL</title>
-    <style>
-      body { margin: 0; }
-      #graphiql { height: 100dvh; }
-    </style>
-    <link rel="stylesheet" href="https://esm.sh/graphiql@5.2.2/dist/style.css" />
-    <script type="importmap">
-      {
-        "imports": {
-          "react": "https://esm.sh/react@19.2.5",
-          "react/": "https://esm.sh/react@19.2.5/",
-          "react-dom": "https://esm.sh/react-dom@19.2.5",
-          "react-dom/": "https://esm.sh/react-dom@19.2.5/",
-          "graphiql": "https://esm.sh/graphiql@5.2.2?standalone&external=react,react-dom,@graphiql/react,graphql",
-          "graphiql/": "https://esm.sh/graphiql@5.2.2/",
-          "@graphiql/react": "https://esm.sh/@graphiql/react@0.37.3?standalone&external=react,react-dom,graphql,@graphiql/toolkit,@emotion/is-prop-valid",
-          "@graphiql/toolkit": "https://esm.sh/@graphiql/toolkit@0.11.3?standalone&external=graphql",
-          "graphql": "https://esm.sh/graphql@16.13.2",
-          "@emotion/is-prop-valid": "data:text/javascript,"
-        }
-      }
-    </script>
-    <script type="module">
-      import React from 'react';
-      import ReactDOM from 'react-dom/client';
-      import { GraphiQL } from 'graphiql';
-      import { createGraphiQLFetcher } from '@graphiql/toolkit';
-      import 'graphiql/setup-workers/esm.sh';
-      const fetcher = createGraphiQLFetcher({ url: "${endpoint}" });
-      function App() {
-        return React.createElement(GraphiQL, { fetcher });
-      }
-      const container = document.getElementById('graphiql');
-      const root = ReactDOM.createRoot(container);
-      root.render(React.createElement(App));
-    </script>
-  </head>
-  <body>
-    <div id="graphiql">Loading\u2026</div>
-  </body>
-</html>`;
-}
 // tsx.ts
 import { createElement, createContext, useContext } from "react";
@@ -1466,21 +1328,920 @@ function compress(options) {
     });
   };
 }
+// graphql.ts
+import { buildSchema, graphql as executeGraphQL } from "graphql";
+import { makeExecutableSchema } from "@graphql-tools/schema";
+function parseParamsFromGet(url) {
+  const query = url.searchParams.get("query");
+  if (!query) return null;
+  let variables = {};
+  const variablesStr = url.searchParams.get("variables");
+  if (variablesStr) {
+    try {
+      variables = JSON.parse(variablesStr);
+    } catch {
+      return null;
+    }
+  }
+  return { query, variables, operationName: url.searchParams.get("operationName") || void 0 };
+}
+async function parseParamsFromPost(req) {
+  try {
+    const body = await req.json();
+    if (!body.query) return null;
+    return { query: body.query, variables: body.variables || {}, operationName: body.operationName };
+  } catch {
+    return null;
+  }
+}
+function buildSchemaFromOptions(options) {
+  if (typeof options.schema === "string") {
+    return options.resolvers ? makeExecutableSchema({ typeDefs: options.schema, resolvers: options.resolvers }) : buildSchema(options.schema);
+  }
+  return options.schema;
+}
+async function executeQuery(schema, params, options, req, ctx) {
+  const contextValue = options.context ? await options.context(req, ctx) : ctx;
+  const result = await executeGraphQL({
+    schema,
+    source: params.query,
+    rootValue: options.rootValue,
+    contextValue,
+    variableValues: params.variables,
+    operationName: params.operationName
+  });
+  return Response.json(result, { status: result.errors ? 400 : 200 });
+}
+function graphiqlHTML(endpoint) {
+  return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>GraphiQL</title>
+    <style>body { margin: 0; } #graphiql { height: 100dvh; }</style>
+    <link rel="stylesheet" href="https://esm.sh/graphiql@5.2.2/dist/style.css" />
+    <script type="importmap">
+      {
+        "imports": {
+          "react": "https://esm.sh/react@19.2.5",
+          "react/": "https://esm.sh/react@19.2.5/",
+          "react-dom": "https://esm.sh/react-dom@19.2.5",
+          "react-dom/": "https://esm.sh/react-dom@19.2.5/",
+          "graphiql": "https://esm.sh/graphiql@5.2.2?standalone&external=react,react-dom,@graphiql/react,graphql",
+          "graphiql/": "https://esm.sh/graphiql@5.2.2/",
+          "@graphiql/react": "https://esm.sh/@graphiql/react@0.37.3?standalone&external=react,react-dom,graphql,@graphiql/toolkit,@emotion/is-prop-valid",
+          "@graphiql/toolkit": "https://esm.sh/@graphiql/toolkit@0.11.3?standalone&external=graphql",
+          "graphql": "https://esm.sh/graphql@16.13.2",
+          "@emotion/is-prop-valid": "data:text/javascript,"
+        }
+      }
+    </script>
+    <script type="module">
+      import React from 'react';
+      import ReactDOM from 'react-dom/client';
+      import { GraphiQL } from 'graphiql';
+      import { createGraphiQLFetcher } from '@graphiql/toolkit';
+      import 'graphiql/setup-workers/esm.sh';
+      const fetcher = createGraphiQLFetcher({ url: "${endpoint}" });
+      function App() {
+        return React.createElement(GraphiQL, { fetcher });
+      }
+      const container = document.getElementById('graphiql');
+      const root = ReactDOM.createRoot(container);
+      root.render(React.createElement(App));
+    </script>
+  </head>
+  <body>
+    <div id="graphiql">Loading\u2026</div>
+  </body>
+</html>`;
+}
+function graphql(handler) {
+  const r = new Router();
+  r.get("/", async (req, ctx) => {
+    const options = await handler(req, ctx);
+    const schema = buildSchemaFromOptions(options);
+    const url = new URL(req.url);
+    if (options.graphiql && !url.searchParams.has("query")) {
+      return new Response(graphiqlHTML(url.pathname), {
+        status: 200,
+        headers: { "Content-Type": "text/html" }
+      });
+    }
+    const params = parseParamsFromGet(url);
+    if (!params) {
+      return Response.json({ errors: [{ message: "Missing query" }] }, { status: 400 });
+    }
+    return executeQuery(schema, params, options, req, ctx);
+  });
+  r.post("/", async (req, ctx) => {
+    const options = await handler(req, ctx);
+    const schema = buildSchemaFromOptions(options);
+    const params = await parseParamsFromPost(req);
+    if (!params) {
+      return Response.json({ errors: [{ message: "Missing query" }] }, { status: 400 });
+    }
+    return executeQuery(schema, params, options, req, ctx);
+  });
+  return r;
+}
+// ai.ts
+import { streamText } from "ai";
+function ai(handler) {
+  const r = new Router();
+  r.post("/", async (req, ctx) => {
+    const options = await handler(req, ctx);
+    const result = streamText(options);
+    return result.toTextStreamResponse();
+  });
+  return r;
+}
+// workflow/tool.ts
+function tool(def) {
+  return {
+    name: def.name ?? "",
+    description: def.description,
+    inputSchema: def.inputSchema,
+    execute: def.execute
+  };
+}
+// workflow/reference.ts
+function getByPath(obj, path) {
+  let current = obj;
+  for (const key of path) {
+    if (current === null || current === void 0) return void 0;
+    if (typeof current === "object" && key in current) {
+      current = current[key];
+    } else {
+      return void 0;
+    }
+  }
+  return current;
+}
+function resolveRef(path, ctx) {
+  if (path.startsWith("$nodes.")) {
+    const afterNodes = path.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 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 (path.startsWith("$var.")) {
+    const name = path.slice(5);
+    if (!ctx.variables.has(name)) {
+      throw new Error(`Variable "${name}" is not defined`);
+    }
+    return ctx.variables.get(name);
+  }
+  if (path.startsWith("$input.")) {
+    const key = path.slice(7);
+    return ctx.input[key];
+  }
+  if (path === "true") return true;
+  if (path === "false") return false;
+  if (path === "null") return null;
+  const num = Number(path);
+  if (!isNaN(num) && path.trim() !== "") return num;
+  return path;
+}
+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 === "object" && v !== null) {
+    const result = {};
+    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 },
+    { op: "!==", fn: (a, b) => a !== b },
+    { op: ">=", fn: (a, b) => Number(a) >= Number(b) },
+    { op: "<=", fn: (a, b) => Number(a) <= Number(b) },
+    { op: ">", fn: (a, b) => Number(a) > Number(b) },
+    { op: "<", fn: (a, b) => Number(a) < Number(b) },
+    { op: "==", fn: (a, b) => a == b },
+    { op: "!=", fn: (a, b) => a != b },
+    { op: "+", fn: (a, b) => Number(a) + Number(b) },
+    { op: "-", fn: (a, b) => Number(a) - Number(b) },
+    { op: "*", fn: (a, b) => Number(a) * Number(b) },
+    { op: "/", fn: (a, b) => Number(a) / Number(b) },
+    { op: "%", fn: (a, b) => Number(a) % Number(b) },
+    { op: "&&", fn: (a, b) => Boolean(a) && Boolean(b) },
+    { op: "||", fn: (a, b) => Boolean(a) || Boolean(b) }
+  ];
+  for (const { op, fn } of operators) {
+    const idx = expr.indexOf(op);
+    if (idx > 0) {
+      const leftRaw = expr.slice(0, idx).trim();
+      const rightRaw = expr.slice(idx + op.length).trim();
+      const left = resolveValue(leftRaw, ctx);
+      const right = resolveValue(rightRaw, ctx);
+      return fn(left, right);
+    }
+  }
+  const trimmed = expr.trim();
+  if (trimmed === "true") return true;
+  if (trimmed === "false") return false;
+  if (trimmed === "null") return null;
+  const num = Number(trimmed);
+  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;
+    }
+  }
+  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 tool3 = ctx.toolRegistry.get(toolName);
+    const resolvedInput = resolveValue(args, ctx);
+    const parsed = tool3.inputSchema.parse(resolvedInput);
+    return tool3.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 } });
+        }
+      }
+    });
+  }
+  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);
+    }
+    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}"`);
+  }
+  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": {} } }
+        ]}
+      ]
+    }
+  ]
+}
+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
+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 text = result.text.trim();
+  const jsonStart = text.indexOf("{");
+  const jsonEnd = text.lastIndexOf("}");
+  if (jsonStart === -1 || jsonEnd === -1) {
+    throw new Error(`LLM output is not valid JSON: ${text.slice(0, 200)}`);
+  }
+  const jsonStr = text.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}`);
+    }
+    throw err;
+  }
+}
+// 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);
+    }
+  }
+  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 };
+    });
+  }
+  return {
+    execute,
+    runAsync,
+    generateWorkflow: generateWorkflow2,
+    getState(workflowId) {
+      return states.get(workflowId);
+    }
+  };
+}
+// workflow/sse.ts
+function createSSEManager() {
+  const streams = /* @__PURE__ */ new Map();
+  const encoder = new TextEncoder();
+  function createStream(workflowId) {
+    const state = {
+      controller: null,
+      encoder,
+      closed: false,
+      buffer: []
+    };
+    const stream = new ReadableStream({
+      start(controller) {
+        state.controller = controller;
+        streams.set(workflowId, state);
+        for (const event of state.buffer) {
+          try {
+            controller.enqueue(encoder.encode(event));
+          } catch {
+            break;
+          }
+        }
+        state.buffer = [];
+      },
+      cancel() {
+        state.closed = true;
+        streams.delete(workflowId);
+      }
+    });
+    return stream;
+  }
+  function send(workflowId, event) {
+    const state = streams.get(workflowId);
+    if (!state || state.closed) return;
+    const data = `event: ${event.event}
+data: ${JSON.stringify(event.data)}
+`;
+    if (state.controller) {
+      try {
+        state.controller.enqueue(encoder.encode(data));
+      } catch {
+        state.closed = true;
+        streams.delete(workflowId);
+      }
+    } else {
+      state.buffer.push(data);
+    }
+  }
+  function close(workflowId) {
+    const state = streams.get(workflowId);
+    if (!state) return;
+    state.closed = true;
+    streams.delete(workflowId);
+    try {
+      state.controller?.close();
+    } catch {
+    }
+  }
+  return { createStream, send, close };
+}
+// workflow/route.ts
+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"
+      }
+    });
+  });
+  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 result = await engine.execute(wf);
+    return Response.json({ workflow: wf, result });
+  });
+  return r;
+}
+// postgres/client.ts
+import postgresFactory from "postgres";
+// postgres/table.ts
+import { z } from "zod";
+function unwrap(field) {
+  let inner = field;
+  while (inner instanceof z.ZodOptional || inner instanceof z.ZodNullable || inner instanceof z.ZodDefault || (inner.constructor.name === "ZodTransform" || inner._def?.type === "transform")) {
+    if (inner._def?.innerType) {
+      inner = inner._def.innerType;
+    } else {
+      break;
+    }
+  }
+  return inner;
+}
+function isOptional(field) {
+  let inner = field;
+  while (true) {
+    if (inner instanceof z.ZodOptional) return true;
+    if (inner instanceof z.ZodNullable) return true;
+    if (inner instanceof z.ZodDefault) {
+      inner = inner._def.innerType;
+      continue;
+    }
+    if (inner._def?.type === "transform") {
+      inner = inner._def.innerType;
+      continue;
+    }
+    break;
+  }
+  return false;
+}
+function hasUUIDCheck(field) {
+  const checks = field._def?.checks ?? [];
+  return checks.some((c) => c.type === "string" && c.def?.format === "uuid");
+}
+function detectSqlType(name, field, isPk) {
+  const inner = unwrap(field);
+  const nullable = isOptional(field);
+  const autoGenerate = isPk && name === "id";
+  if (isPk && name === "id" && inner instanceof z.ZodNumber) {
+    return { sqlType: "SERIAL", nullable: false, defaultExpr: null, autoGenerate: true };
+  }
+  if (isPk && name === "id" && typeof BigInt !== "undefined" && inner instanceof z.ZodBigInt) {
+    return { sqlType: "BIGSERIAL", nullable: false, defaultExpr: null, autoGenerate: true };
+  }
+  if (isPk && name === "id" && inner instanceof z.ZodString) {
+    if (hasUUIDCheck(inner)) {
+      return { sqlType: "UUID", nullable: false, defaultExpr: "gen_random_uuid()", autoGenerate: true };
+    }
+    return { sqlType: "TEXT", nullable: false, defaultExpr: null, autoGenerate: false };
+  }
+  let sqlType;
+  if (inner instanceof z.ZodNumber) {
+    sqlType = "INTEGER";
+  } else if (inner instanceof z.ZodString) {
+    sqlType = "TEXT";
+  } else if (inner instanceof z.ZodBoolean) {
+    sqlType = "BOOLEAN";
+  } else if (inner instanceof z.ZodDate) {
+    sqlType = "TIMESTAMPTZ";
+  } else if (inner instanceof z.ZodEnum) {
+    sqlType = "TEXT";
+  } else if (inner instanceof z.ZodArray) {
+    sqlType = "JSONB";
+  } else if (inner instanceof z.ZodObject) {
+    sqlType = "JSONB";
+  } else {
+    sqlType = "TEXT";
+  }
+  return { sqlType, nullable: nullable || autoGenerate, defaultExpr: null, autoGenerate };
+}
+function parseColumns(schema) {
+  const pkField = Object.keys(schema).find((k) => k === "id");
+  return Object.entries(schema).map(([name, field]) => {
+    const isPk = name === pkField;
+    const { sqlType, nullable, defaultExpr, autoGenerate } = detectSqlType(name, field, isPk);
+    return { name, sqlType, nullable: nullable || autoGenerate, isPrimaryKey: isPk, defaultExpr, autoGenerate };
+  });
+}
+function buildGet(sql, name, pk) {
+  return async function get(id2) {
+    if (!pk) throw new Error(`Table "${name}" has no primary key`);
+    const [row] = await sql`SELECT * FROM ${sql(name)} WHERE ${sql(pk.name)} = ${id2} LIMIT 1`;
+    return row ?? void 0;
+  };
+}
+function buildList(sql, name, columns) {
+  return async function list(filter = {}, opts = {}) {
+    const colNames = new Set(columns.map((c) => c.name));
+    const whereClauses = [];
+    const whereValues = [];
+    for (const [key, value] of Object.entries(filter)) {
+      if (colNames.has(key)) {
+        whereClauses.push(`"${key}" = $${whereValues.length + 1}`);
+        whereValues.push(value);
+      }
+    }
+    const where = whereClauses.length > 0 ? `WHERE ${whereClauses.join(" AND ")}` : "";
+    const sortClauses = [];
+    if (opts.sort) {
+      for (const [key, dir] of Object.entries(opts.sort)) {
+        if (colNames.has(key)) {
+          sortClauses.push(`"${key}" ${dir.toUpperCase()}`);
+        }
+      }
+    }
+    const orderBy = sortClauses.length > 0 ? `ORDER BY ${sortClauses.join(", ")}` : "";
+    const limitClause = opts.limit != null ? `LIMIT ${opts.limit}` : "";
+    const offsetClause = opts.offset != null ? `OFFSET ${opts.offset}` : "";
+    const [rows, countResult] = await Promise.all([
+      sql.unsafe(`SELECT * FROM "${name}" ${where} ${orderBy} ${limitClause} ${offsetClause}`.trim(), whereValues),
+      sql.unsafe(`SELECT count(*) as count FROM "${name}" ${where}`.trim(), whereValues)
+    ]);
+    return { rows, count: Number(countResult[0]?.count ?? 0) };
+  };
+}
+function buildCreate(sql, name, pk, zodSchema) {
+  return async function create(data) {
+    const validated = zodSchema.parse(data);
+    if (pk?.autoGenerate) {
+      delete validated[pk.name];
+    }
+    const [row] = await sql`INSERT INTO ${sql(name)} ${sql(validated)} RETURNING *`;
+    return row;
+  };
+}
+function buildPatch(sql, name, pk, zodSchema) {
+  return async function patch(id2, data) {
+    if (!pk) throw new Error(`Table "${name}" has no primary key`);
+    const validated = zodSchema.partial().parse(data);
+    delete validated[pk.name];
+    if (Object.keys(validated).length === 0) {
+      const [row2] = await sql`SELECT * FROM ${sql(name)} WHERE ${sql(pk.name)} = ${id2} LIMIT 1`;
+      return row2 ?? void 0;
+    }
+    const [row] = await sql`UPDATE ${sql(name)} SET ${sql(validated)} WHERE ${sql(pk.name)} = ${id2} RETURNING *`;
+    return row ?? void 0;
+  };
+}
+function buildRemove(sql, name, pk) {
+  return async function remove(id2) {
+    if (!pk) throw new Error(`Table "${name}" has no primary key`);
+    const rows = await sql`DELETE FROM ${sql(name)} WHERE ${sql(pk.name)} = ${id2} RETURNING 1`;
+    return rows.length > 0;
+  };
+}
+function buildTable(sql, tables) {
+  return function table(name, schema) {
+    const zodSchema = z.object(schema);
+    const columns = parseColumns(schema);
+    const pk = columns.find((c) => c.isPrimaryKey) ?? void 0;
+    tables.push({ name, columns });
+    return {
+      $type: void 0,
+      $insert: void 0,
+      get: buildGet(sql, name, pk),
+      list: buildList(sql, name, columns),
+      create: buildCreate(sql, name, pk, zodSchema),
+      patch: buildPatch(sql, name, pk, zodSchema),
+      remove: buildRemove(sql, name, pk)
+    };
+  };
+}
+// postgres/migrate.ts
+function toDDL(col) {
+  const parts = [`"${col.name}"`, col.sqlType];
+  if (col.isPrimaryKey) parts.push("PRIMARY KEY");
+  if (!col.isPrimaryKey && !col.nullable) parts.push("NOT NULL");
+  if (col.defaultExpr) parts.push(`DEFAULT ${col.defaultExpr}`);
+  return parts.join(" ");
+}
+function createTableSQL(name, columns) {
+  const cols = columns.map(toDDL);
+  return `CREATE TABLE IF NOT EXISTS "${name}" (
+  ${cols.join(",\n  ")}
+)`;
+}
+function addColumnSQL(name, col) {
+  return `ALTER TABLE "${name}" ADD COLUMN IF NOT EXISTS ${toDDL(col)}`;
+}
+async function runMigrations(sql, tables) {
+  for (const table of tables) {
+    const existing = await sql`
+      SELECT column_name FROM information_schema.columns
+      WHERE table_schema = 'public' AND table_name = ${table.name}
+    `;
+    if (existing.length === 0) {
+      await sql.unsafe(createTableSQL(table.name, table.columns));
+    } else {
+      const colNames = new Set(existing.map((r) => r.column_name));
+      for (const col of table.columns) {
+        if (!colNames.has(col.name)) {
+          await sql.unsafe(addColumnSQL(table.name, col));
+        }
+      }
+    }
+  }
+}
+// postgres/client.ts
+function postgres(opts) {
+  const options = typeof opts === "string" ? { connection: opts } : opts ?? {};
+  const connection = options.connection ?? process.env.DATABASE_URL;
+  if (!connection) {
+    throw new Error(
+      "postgres: DATABASE_URL is not set. Pass a connection string or set the DATABASE_URL environment variable."
+    );
+  }
+  const sql = postgresFactory(connection);
+  const tables = [];
+  if (options.signal) {
+    options.signal.addEventListener("abort", () => {
+      sql.end();
+    }, { once: true });
+  }
+  const mw = ((req, ctx, next) => {
+    ctx.sql = sql;
+    return next(req, ctx);
+  });
+  mw.sql = sql;
+  mw.table = buildTable(sql, tables);
+  mw.migrate = () => runMigrations(sql, tables);
+  mw.close = () => sql.end({ timeout: 5 });
+  return mw;
+}
 export {
   Router,
   TsxContext,
+  ai,
   auth,
   compress,
   cors,
+  createSSEManager,
+  createWorkflowEngine,
   deleteCookie,
+  generateWorkflow,
   getCookies,
+  graphql,
   logger,
+  postgres,
   rateLimit,
   serve,
   serveStatic,
   setCookie,
+  tool,
   tsx,
   upload,
   useTsx,
-  validate
+  validate,
+  workflow
 };