weifuwu 0.3.0 → 0.4.0

package/README.md

@@ -18,6 +18,7 @@ Features like `tsx()`, WebSocket, GraphQL, and AI streaming all follow the same
 - **WebSocket** — `router.ws()` with upgrade middleware (auth before connect)
 - **GraphQL** — `router.graphql()` with GraphiQL IDE
 - **AI streaming** — `router.ai()` via Vercel AI SDK
+- **AI workflows** — `router.workflow()` — intent-to-execution pipelines with `tool()` + SSE
 - **Static files** — `serveStatic()` with ETag, 304, MIME, directory index
 - **Request validation** — `validate()` with Zod (body / query / params / headers)
 - **File upload** — `upload()` multipart parser with disk save, size & type limits
@@ -430,6 +431,35 @@ const app = new Router()
 serve(app.handler(), { port: 3000 })
 ```
 
+## Workflow
+
+Define tools (business capabilities) and let AI generate and execute multi-step workflows.
+
+```ts
+import { Router, tool, createWorkflowEngine } from 'weifuwu'
+import { z } from 'zod'
+
+const tools = {
+  queryUser: tool({
+    description: '查询用户信息，返回 email, name',
+    inputSchema: z.object({ userId: z.string() }),
+    execute: async ({ userId }) => ({ id: userId, email: 'user@test.com', name: 'Test' }),
+  }),
+}
+
+const app = new Router()
+
+// Router method — accepts { nodes } or { goal } with model
+app.workflow('/api/agent', { tools })
+
+// Or manual execution
+const engine = createWorkflowEngine({ tools })
+const result = await engine.execute({ nodes: [
+  { id: 's1', tool: 'set', input: { name: 'msg', value: 'hello' } },
+  { id: 'g1', tool: 'get', input: { name: 'msg' } },
+]})
+```
+
 ## Graceful shutdown
 
 ```ts

package/dist/index.d.ts

@@ -19,3 +19,5 @@ export { rateLimit } from './rate-limit.ts';
 export type { RateLimitOptions } from './rate-limit.ts';
 export { compress } from './compress.ts';
 export type { CompressOptions } from './compress.ts';
+export { tool, createWorkflowEngine, createSSEManager, generateWorkflow } from './workflow/index.ts';
+export type { Tool, Workflow, WorkflowEngine, WorkflowState, SSEEvent } from './workflow/types.ts';

package/dist/index.js

@@ -110,6 +110,490 @@ import { WebSocketServer } from "ws";
 import { buildSchema, graphql } from "graphql";
 import { makeExecutableSchema } from "@graphql-tools/schema";
 import { streamText } from "ai";
+
+// 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 workflow = JSON.parse(jsonStr);
+    if (!workflow.nodes || !Array.isArray(workflow.nodes)) {
+      throw new Error("Generated workflow has no nodes array");
+    }
+    return workflow;
+  } 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(workflow, opts) {
+    const ctx = {
+      variables: /* @__PURE__ */ new Map(),
+      nodeOutputs: /* @__PURE__ */ new Map(),
+      functions: workflow.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 workflow.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, workflow, opts) {
+    const state = {
+      workflowId,
+      status: "running",
+      goal: workflow.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(workflow, { ...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 };
+}
+
+// router.ts
 var createTrieNode = () => ({
   children: /* @__PURE__ */ new Map(),
   handlers: /* @__PURE__ */ new Map(),
@@ -302,6 +786,50 @@ var Router = class _Router {
     };
     return this.post(path, ...middlewares, routeHandler);
   }
+  workflow(path, options) {
+    const sseManager = options.stream ? createSSEManager() : void 0;
+    if (options.stream && sseManager) {
+      this.get(`${path}/: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"
+          }
+        });
+      });
+    }
+    this.post(path, async (req) => {
+      const body = await req.json();
+      const engine = createWorkflowEngine({
+        tools: options.tools,
+        model: options.model,
+        sseManager
+      });
+      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: `${path}/${workflowId}/events` });
+      }
+      const result = await engine.execute(wf);
+      return Response.json({ workflow: wf, result });
+    });
+    return this;
+  }
   handler() {
     return (req, ctx) => {
       const url = new URL(req.url);
@@ -1472,13 +2000,17 @@ export {
   auth,
   compress,
   cors,
+  createSSEManager,
+  createWorkflowEngine,
   deleteCookie,
+  generateWorkflow,
   getCookies,
   logger,
   rateLimit,
   serve,
   serveStatic,
   setCookie,
+  tool,
   tsx,
   upload,
   useTsx,

package/dist/router.d.ts

@@ -2,8 +2,9 @@ import { type WebSocket } from 'ws';
 import type { IncomingMessage } from 'node:http';
 import type { Duplex } from 'node:stream';
 import { type GraphQLSchema } from 'graphql';
-import { streamText } from 'ai';
+import { streamText, generateText } from 'ai';
 import type { Context, Handler, Middleware, ErrorHandler } from './types.ts';
+import type { Tool as WfTool } from './workflow/types.ts';
 type StreamTextParams = Parameters<typeof streamText>[0];
 export type WebSocketHandler = {
     open?: (ws: WebSocket, ctx: Context) => void | Promise<void>;
@@ -44,6 +45,11 @@ export declare class Router {
     ws(path: string, ...args: [...Middleware[], WebSocketHandler]): this;
     graphql(path: string, ...args: [...Middleware[], GraphQLOptions]): this;
     ai(path: string, ...args: [...Middleware[], AIHandler]): this;
+    workflow(path: string, options: {
+        tools: Record<string, WfTool>;
+        model?: Parameters<typeof generateText>[0]['model'];
+        stream?: boolean;
+    }): this;
     handler(): Handler;
     websocketHandler(): WsUpgradeHandler;
     private splitPath;

package/dist/workflow/engine.d.ts

@@ -0,0 +1,7 @@
+import type { Tool, WorkflowEngine, SSEManager } from './types.ts';
+import { type LanguageModel } from 'ai';
+export declare function createWorkflowEngine(options: {
+    tools: Record<string, Tool>;
+    sseManager?: SSEManager;
+    model?: LanguageModel;
+}): WorkflowEngine;

package/dist/workflow/index.d.ts

@@ -0,0 +1,6 @@
+export { tool } from './tool.ts';
+export { createWorkflowEngine } from './engine.ts';
+export { createSSEManager } from './sse.ts';
+export { resolveRef, resolveValue } from './reference.ts';
+export { generateWorkflow } from './llm.ts';
+export type { Tool, ToolContext, Workflow, Node, WorkflowState, SSEEvent, SSEManager, WorkflowEngine, ExecuteOptions, StreamEvent, Condition, SubWorkflow } from './types.ts';

package/dist/workflow/llm.d.ts

@@ -0,0 +1,10 @@
+import type { Tool, Workflow } from './types.ts';
+export declare function generateWorkflow(goal: string, tools: Record<string, Tool>, generateFn: (prompt: {
+    system: string;
+    messages: {
+        role: string;
+        content: string;
+    }[];
+}) => Promise<{
+    text: string;
+}>): Promise<Workflow>;

package/dist/workflow/nodes.d.ts

@@ -0,0 +1,10 @@
+import type { Node, WorkflowContext } from './types.ts';
+export type NodeExecutor = (node: Node, ctx: WorkflowContext) => Promise<unknown>;
+export declare function executeEval(node: Node, ctx: WorkflowContext): Promise<unknown>;
+export declare function executeSet(node: Node, ctx: WorkflowContext): Promise<unknown>;
+export declare function executeGet(node: Node, ctx: WorkflowContext): Promise<unknown>;
+export declare function executeIf(node: Node, ctx: WorkflowContext): Promise<unknown>;
+export declare function executeWhile(node: Node, ctx: WorkflowContext): Promise<unknown>;
+export declare function executeCall(node: Node, ctx: WorkflowContext): Promise<unknown>;
+export declare function executeHttp(node: Node, ctx: WorkflowContext): Promise<unknown>;
+export declare function executeNode(node: Node, ctx: WorkflowContext): Promise<unknown>;

package/dist/workflow/reference.d.ts

@@ -0,0 +1,3 @@
+import type { WorkflowContext } from './types.ts';
+export declare function resolveRef(path: string, ctx: WorkflowContext): unknown;
+export declare function resolveValue(v: unknown, ctx: WorkflowContext): unknown;

package/dist/workflow/sse.d.ts

@@ -0,0 +1,2 @@
+import type { SSEManager } from './types.ts';
+export declare function createSSEManager(): SSEManager;

package/dist/workflow/tool.d.ts

@@ -0,0 +1,8 @@
+import type { z } from 'zod';
+import type { Tool, ToolContext } from './types.ts';
+export declare function tool<TInput = unknown, TOutput = unknown>(def: {
+    name?: string;
+    description: string;
+    inputSchema: z.ZodSchema<TInput>;
+    execute: (input: TInput, ctx: ToolContext) => Promise<TOutput>;
+}): Tool<TInput, TOutput>;

package/dist/workflow/types.d.ts

@@ -0,0 +1,86 @@
+import type { z } from 'zod';
+export type NodeType = 'eval' | 'set' | 'get' | 'if' | 'while' | 'call' | 'http';
+export interface Tool<TInput = unknown, TOutput = unknown> {
+    name: string;
+    description: string;
+    inputSchema: z.ZodSchema<TInput>;
+    execute: (input: TInput, ctx: ToolContext) => Promise<TOutput>;
+}
+export interface ToolContext {
+    workflowId?: string;
+    nodeId: string;
+    onStream?: (event: StreamEvent) => Promise<void>;
+}
+export interface StreamEvent {
+    type: string;
+    chunk?: string;
+    accumulated?: string;
+    [key: string]: unknown;
+}
+export interface Node {
+    id: string;
+    tool: NodeType | string;
+    input: Record<string, unknown>;
+    conditions?: Condition[];
+    body?: Node[];
+}
+export interface Condition {
+    test: string | boolean;
+    body: Node[];
+}
+export interface Workflow {
+    name?: string;
+    nodes: Node[];
+    functions?: Record<string, SubWorkflow>;
+}
+export interface SubWorkflow {
+    inputSchema: Record<string, unknown>;
+    workflow: {
+        nodes: Node[];
+    };
+}
+export interface WorkflowState {
+    workflowId: string;
+    status: 'running' | 'completed' | 'error';
+    goal: string;
+    result?: unknown;
+    error?: string;
+    startTime: number;
+    endTime?: number;
+}
+export interface SSEEvent {
+    event: string;
+    data: unknown;
+}
+export interface ExecuteOptions {
+    initialInput?: Record<string, unknown>;
+    maxSteps?: number;
+}
+export interface WorkflowContext {
+    variables: Map<string, unknown>;
+    nodeOutputs: Map<string, unknown>;
+    functions: Record<string, SubWorkflow>;
+    stepCount: number;
+    maxSteps: number;
+    input: Record<string, unknown>;
+    toolRegistry: Map<string, Tool>;
+    sseManager?: SSEManager;
+    workflowId?: string;
+    onNodeEvent?: (event: SSEEvent) => void;
+}
+export interface SSEManager {
+    createStream: (workflowId: string) => ReadableStream<Uint8Array>;
+    send: (workflowId: string, event: SSEEvent) => void;
+    close: (workflowId: string) => void;
+}
+export interface EngineOptions {
+    tools: Record<string, Tool>;
+    model?: unknown;
+    sseManager?: SSEManager;
+}
+export interface WorkflowEngine {
+    execute: (workflow: Workflow, options?: ExecuteOptions) => Promise<unknown>;
+    getState: (workflowId: string) => WorkflowState | undefined;
+    runAsync: (workflowId: string, workflow: Workflow, options?: ExecuteOptions) => Promise<void>;
+    generateWorkflow: (goal: string) => Promise<Workflow>;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "weifuwu",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Web-standard HTTP framework for Node.js — (req, ctx) => Response",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",