@witqq/agent-sdk 0.1.0

package/dist/backends/vercel-ai.js

@@ -0,0 +1,615 @@
+// src/types.ts
+function getTextContent(content) {
+  if (typeof content === "string") return content;
+  return content.filter((p) => p.type === "text").map((p) => p.text).join("\n");
+}
+
+// src/errors.ts
+var AgentSDKError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "AgentSDKError";
+  }
+};
+var ReentrancyError = class extends AgentSDKError {
+  constructor() {
+    super("Agent is already running. Await the current run before starting another.");
+    this.name = "ReentrancyError";
+  }
+};
+var DisposedError = class extends AgentSDKError {
+  constructor(entity) {
+    super(`${entity} has been disposed and cannot be used.`);
+    this.name = "DisposedError";
+  }
+};
+var DependencyError = class extends AgentSDKError {
+  packageName;
+  constructor(packageName) {
+    super(`${packageName} is not installed. Install it: npm install ${packageName}`);
+    this.name = "DependencyError";
+    this.packageName = packageName;
+  }
+};
+var AbortError = class extends AgentSDKError {
+  constructor() {
+    super("Agent run was aborted.");
+    this.name = "AbortError";
+  }
+};
+var ToolExecutionError = class extends AgentSDKError {
+  toolName;
+  constructor(toolName, message, options) {
+    super(`Tool "${toolName}" failed: ${message}`, options);
+    this.name = "ToolExecutionError";
+    this.toolName = toolName;
+  }
+};
+
+// src/base-agent.ts
+var BaseAgent = class {
+  state = "idle";
+  abortController = null;
+  config;
+  constructor(config) {
+    this.config = Object.freeze({ ...config });
+  }
+  // ─── Public Interface ─────────────────────────────────────────
+  async run(prompt, options) {
+    this.guardReentrancy();
+    this.guardDisposed();
+    const ac = this.createAbortController(options?.signal);
+    this.state = "running";
+    try {
+      const messages = [{ role: "user", content: prompt }];
+      return await this.executeRun(messages, options, ac.signal);
+    } finally {
+      this.state = "idle";
+      this.abortController = null;
+    }
+  }
+  async runWithContext(messages, options) {
+    this.guardReentrancy();
+    this.guardDisposed();
+    const ac = this.createAbortController(options?.signal);
+    this.state = "running";
+    try {
+      return await this.executeRun(messages, options, ac.signal);
+    } finally {
+      this.state = "idle";
+      this.abortController = null;
+    }
+  }
+  async runStructured(prompt, schema, options) {
+    this.guardReentrancy();
+    this.guardDisposed();
+    const ac = this.createAbortController(options?.signal);
+    this.state = "running";
+    try {
+      const messages = [{ role: "user", content: prompt }];
+      return await this.executeRunStructured(
+        messages,
+        schema,
+        options,
+        ac.signal
+      );
+    } finally {
+      this.state = "idle";
+      this.abortController = null;
+    }
+  }
+  async *stream(prompt, options) {
+    this.guardReentrancy();
+    this.guardDisposed();
+    const ac = this.createAbortController(options?.signal);
+    this.state = "streaming";
+    try {
+      const messages = [{ role: "user", content: prompt }];
+      yield* this.executeStream(messages, options, ac.signal);
+    } finally {
+      this.state = "idle";
+      this.abortController = null;
+    }
+  }
+  abort() {
+    if (this.abortController) {
+      this.abortController.abort();
+    }
+  }
+  getState() {
+    return this.state;
+  }
+  getConfig() {
+    return this.config;
+  }
+  /** Mark agent as disposed. Override to add cleanup. */
+  dispose() {
+    this.abort();
+    this.state = "disposed";
+  }
+  // ─── Guards ───────────────────────────────────────────────────
+  guardReentrancy() {
+    if (this.state === "running" || this.state === "streaming") {
+      throw new ReentrancyError();
+    }
+  }
+  guardDisposed() {
+    if (this.state === "disposed") {
+      throw new DisposedError("Agent");
+    }
+  }
+  /** Throw AbortError if signal is already aborted */
+  checkAbort(signal) {
+    if (signal.aborted) {
+      throw new AbortError();
+    }
+  }
+  // ─── Internal Helpers ─────────────────────────────────────────
+  createAbortController(externalSignal) {
+    const ac = new AbortController();
+    this.abortController = ac;
+    if (externalSignal) {
+      if (externalSignal.aborted) {
+        ac.abort();
+      } else {
+        externalSignal.addEventListener("abort", () => ac.abort(), {
+          once: true
+        });
+      }
+    }
+    return ac;
+  }
+};
+
+// src/utils/schema.ts
+function zodToJsonSchema(schema) {
+  const schemaAny = schema;
+  if ("jsonSchema" in schema && typeof schemaAny.jsonSchema === "function") {
+    return schemaAny.jsonSchema();
+  }
+  return extractSchemaFromDef(schema);
+}
+function extractSchemaFromDef(schema) {
+  const def = schema._def;
+  const typeName = def.typeName;
+  switch (typeName) {
+    case "ZodString":
+      return { type: "string" };
+    case "ZodNumber":
+      return { type: "number" };
+    case "ZodBoolean":
+      return { type: "boolean" };
+    case "ZodNull":
+      return { type: "null" };
+    case "ZodArray":
+      return {
+        type: "array",
+        items: extractSchemaFromDef(def.type)
+      };
+    case "ZodObject": {
+      const shape = schema.shape;
+      const properties = {};
+      const required = [];
+      for (const [key, value] of Object.entries(shape)) {
+        const valueDef = value._def;
+        if (valueDef.typeName === "ZodOptional") {
+          properties[key] = extractSchemaFromDef(valueDef.innerType);
+        } else {
+          properties[key] = extractSchemaFromDef(value);
+          required.push(key);
+        }
+      }
+      return {
+        type: "object",
+        properties,
+        ...required.length > 0 ? { required } : {}
+      };
+    }
+    case "ZodOptional":
+      return extractSchemaFromDef(def.innerType);
+    case "ZodEnum":
+      return { type: "string", enum: def.values };
+    default:
+      return {};
+  }
+}
+
+// src/backends/vercel-ai.ts
+var sdkModule = null;
+var compatModule = null;
+async function loadSDK() {
+  if (sdkModule) return sdkModule;
+  try {
+    sdkModule = await import('ai');
+    return sdkModule;
+  } catch {
+    throw new DependencyError("ai");
+  }
+}
+async function loadCompat() {
+  if (compatModule) return compatModule;
+  try {
+    compatModule = await import('@ai-sdk/openai-compatible');
+    return compatModule;
+  } catch {
+    throw new DependencyError("@ai-sdk/openai-compatible");
+  }
+}
+function _injectSDK(mock) {
+  sdkModule = mock;
+}
+function _injectCompat(mock) {
+  compatModule = mock;
+}
+function _resetSDK() {
+  sdkModule = null;
+  compatModule = null;
+}
+var DEFAULT_BASE_URL = "https://openrouter.ai/api/v1";
+var DEFAULT_PROVIDER = "openrouter";
+var DEFAULT_MAX_TURNS = 10;
+function mapToolsToSDK(sdk, tools, config, sessionApprovals, permissionStore, signal) {
+  const toolMap = {};
+  const supervisor = config.supervisor;
+  for (const ourTool of tools) {
+    const jsonSchema = zodToJsonSchema(ourTool.parameters);
+    toolMap[ourTool.name] = sdk.tool({
+      description: ourTool.description,
+      parameters: sdk.jsonSchema(jsonSchema),
+      execute: wrapToolExecute(ourTool, supervisor, sessionApprovals, permissionStore, signal),
+      ...ourTool.needsApproval && supervisor?.onPermission ? {
+        needsApproval: async (_args) => {
+          if (permissionStore && await permissionStore.isApproved(ourTool.name)) return false;
+          if (sessionApprovals.has(ourTool.name)) return false;
+          return true;
+        }
+      } : {}
+    });
+  }
+  if (supervisor?.onAskUser) {
+    const onAskUser = supervisor.onAskUser;
+    toolMap["ask_user"] = sdk.tool({
+      description: "Ask the user a question and wait for their response",
+      parameters: sdk.jsonSchema({
+        type: "object",
+        properties: {
+          question: { type: "string", description: "The question to ask the user" }
+        },
+        required: ["question"]
+      }),
+      execute: async (args) => {
+        const response = await onAskUser(
+          { question: args.question, allowFreeform: true },
+          signal
+        );
+        return response.answer;
+      }
+    });
+  }
+  return toolMap;
+}
+function wrapToolExecute(ourTool, supervisor, sessionApprovals, permissionStore, signal) {
+  return async (args) => {
+    if (ourTool.needsApproval && supervisor?.onPermission) {
+      const storeApproved = permissionStore && await permissionStore.isApproved(ourTool.name);
+      if (!storeApproved && !sessionApprovals.has(ourTool.name)) {
+        const request = {
+          toolName: ourTool.name,
+          toolArgs: args ?? {}
+        };
+        const decision = await supervisor.onPermission(
+          request,
+          signal
+        );
+        if (!decision.allowed) {
+          throw new ToolExecutionError(
+            ourTool.name,
+            decision.reason ?? "Permission denied"
+          );
+        }
+        if (permissionStore && decision.scope) {
+          await permissionStore.approve(ourTool.name, decision.scope);
+        }
+        if (decision.scope === "session" || decision.scope === "always" || decision.scope === "project") {
+          sessionApprovals.add(ourTool.name);
+        }
+        if (decision.modifiedInput) {
+          args = decision.modifiedInput;
+        }
+      }
+    }
+    try {
+      const result = await ourTool.execute(args);
+      return result;
+    } catch (e) {
+      if (e instanceof ToolExecutionError) throw e;
+      throw new ToolExecutionError(
+        ourTool.name,
+        e instanceof Error ? e.message : String(e)
+      );
+    }
+  };
+}
+function messagesToSDK(messages) {
+  return messages.map((msg) => {
+    switch (msg.role) {
+      case "user":
+        return { role: "user", content: getTextContent(msg.content) };
+      case "assistant":
+        return { role: "assistant", content: getTextContent(msg.content) };
+      case "system":
+        return { role: "system", content: msg.content };
+      case "tool":
+        return { role: "tool", content: msg.content ?? "" };
+      default:
+        return { role: "user", content: "" };
+    }
+  });
+}
+function mapStreamPart(part) {
+  switch (part.type) {
+    case "text-delta":
+      return { type: "text_delta", text: part.text ?? "" };
+    case "tool-call":
+      return {
+        type: "tool_call_start",
+        toolName: part.toolName ?? "unknown",
+        args: part.args ?? {}
+      };
+    case "tool-result":
+      return {
+        type: "tool_call_end",
+        toolName: part.toolName ?? "unknown",
+        result: part.result ?? null
+      };
+    case "tool-error":
+      return {
+        type: "error",
+        error: part.error instanceof Error ? part.error.message : String(part.error ?? "Tool execution failed"),
+        recoverable: true
+      };
+    case "reasoning-start":
+      return { type: "thinking_start" };
+    case "reasoning-end":
+      return { type: "thinking_end" };
+    case "reasoning-delta":
+      return { type: "text_delta", text: part.text ?? "" };
+    case "finish-step":
+      return {
+        type: "usage_update",
+        promptTokens: Number(part.usage?.inputTokens ?? 0),
+        completionTokens: Number(part.usage?.outputTokens ?? 0)
+      };
+    case "error":
+      return {
+        type: "error",
+        error: part.error instanceof Error ? part.error.message : String(part.error ?? "Unknown error"),
+        recoverable: false
+      };
+    default:
+      return null;
+  }
+}
+var VercelAIAgent = class extends BaseAgent {
+  backendOptions;
+  sessionApprovals = /* @__PURE__ */ new Set();
+  model = null;
+  constructor(config, backendOptions) {
+    super(config);
+    this.backendOptions = backendOptions;
+  }
+  async getModel() {
+    if (this.model) return this.model;
+    const compat = await loadCompat();
+    const provider = compat.createOpenAICompatible({
+      name: this.backendOptions.provider ?? DEFAULT_PROVIDER,
+      baseURL: this.backendOptions.baseUrl ?? DEFAULT_BASE_URL,
+      apiKey: this.backendOptions.apiKey
+    });
+    const modelId = this.config.model ?? "anthropic/claude-sonnet-4-5";
+    this.model = provider.chatModel(modelId);
+    return this.model;
+  }
+  async getSDKTools(signal) {
+    const sdk = await loadSDK();
+    return mapToolsToSDK(sdk, this.config.tools, this.config, this.sessionApprovals, this.config.permissionStore, signal);
+  }
+  // ─── executeRun ─────────────────────────────────────────────────
+  async executeRun(messages, _options, signal) {
+    this.checkAbort(signal);
+    const sdk = await loadSDK();
+    const model = await this.getModel();
+    const tools = await this.getSDKTools(signal);
+    const maxTurns = this.config.maxTurns ?? DEFAULT_MAX_TURNS;
+    const sdkMessages = messagesToSDK(messages);
+    const hasTools = Object.keys(tools).length > 0;
+    const result = await sdk.generateText({
+      model,
+      system: this.config.systemPrompt,
+      messages: sdkMessages,
+      tools: hasTools ? tools : void 0,
+      maxSteps: maxTurns,
+      abortSignal: signal,
+      ...this.config.modelParams?.temperature !== void 0 && {
+        temperature: this.config.modelParams.temperature
+      },
+      ...this.config.modelParams?.maxTokens !== void 0 && {
+        maxTokens: this.config.modelParams.maxTokens
+      },
+      ...this.config.modelParams?.topP !== void 0 && {
+        topP: this.config.modelParams.topP
+      }
+    });
+    const toolCalls = [];
+    for (const step of result.steps) {
+      for (const tc of step.toolCalls) {
+        const matchingResult = step.toolResults.find(
+          (tr) => tr.toolCallId === tc.toolCallId
+        );
+        toolCalls.push({
+          toolName: tc.toolName,
+          args: tc.args ?? {},
+          result: matchingResult?.result ?? null,
+          approved: true
+        });
+      }
+    }
+    const usage = {
+      promptTokens: Number(result.totalUsage?.inputTokens ?? 0),
+      completionTokens: Number(result.totalUsage?.outputTokens ?? 0)
+    };
+    return {
+      output: result.text || null,
+      structuredOutput: void 0,
+      toolCalls,
+      messages: [
+        ...messages,
+        ...result.text ? [{ role: "assistant", content: result.text }] : []
+      ],
+      usage
+    };
+  }
+  // ─── executeRunStructured ───────────────────────────────────────
+  async executeRunStructured(messages, schema, _options, signal) {
+    this.checkAbort(signal);
+    const sdk = await loadSDK();
+    const model = await this.getModel();
+    const sdkMessages = messagesToSDK(messages);
+    const jsonSchema = zodToJsonSchema(schema.schema);
+    const result = await sdk.generateObject({
+      model,
+      system: this.config.systemPrompt,
+      messages: sdkMessages,
+      schema: sdk.jsonSchema(jsonSchema),
+      schemaName: schema.name,
+      schemaDescription: schema.description,
+      abortSignal: signal,
+      ...this.config.modelParams?.temperature !== void 0 && {
+        temperature: this.config.modelParams.temperature
+      },
+      ...this.config.modelParams?.maxTokens !== void 0 && {
+        maxTokens: this.config.modelParams.maxTokens
+      }
+    });
+    let structuredOutput;
+    try {
+      structuredOutput = schema.schema.parse(result.object);
+    } catch {
+    }
+    const usage = {
+      promptTokens: Number(result.usage?.inputTokens ?? 0),
+      completionTokens: Number(result.usage?.outputTokens ?? 0)
+    };
+    return {
+      output: JSON.stringify(result.object),
+      structuredOutput,
+      toolCalls: [],
+      messages: [
+        ...messages,
+        ...result.object != null ? [{ role: "assistant", content: JSON.stringify(result.object) }] : []
+      ],
+      usage
+    };
+  }
+  // ─── executeStream ──────────────────────────────────────────────
+  async *executeStream(messages, _options, signal) {
+    this.checkAbort(signal);
+    const sdk = await loadSDK();
+    const model = await this.getModel();
+    const tools = await this.getSDKTools(signal);
+    const maxTurns = this.config.maxTurns ?? DEFAULT_MAX_TURNS;
+    const sdkMessages = messagesToSDK(messages);
+    const hasTools = Object.keys(tools).length > 0;
+    const result = sdk.streamText({
+      model,
+      system: this.config.systemPrompt,
+      messages: sdkMessages,
+      tools: hasTools ? tools : void 0,
+      maxSteps: maxTurns,
+      abortSignal: signal,
+      ...this.config.modelParams?.temperature !== void 0 && {
+        temperature: this.config.modelParams.temperature
+      },
+      ...this.config.modelParams?.maxTokens !== void 0 && {
+        maxTokens: this.config.modelParams.maxTokens
+      },
+      ...this.config.modelParams?.topP !== void 0 && {
+        topP: this.config.modelParams.topP
+      }
+    });
+    let finalText = "";
+    try {
+      for await (const part of result.fullStream) {
+        if (signal.aborted) throw new AbortError();
+        const event = mapStreamPart(part);
+        if (event) yield event;
+        if (part.type === "text-delta") {
+          finalText += part.text ?? "";
+        }
+      }
+      const totalUsage = await result.totalUsage;
+      yield {
+        type: "usage_update",
+        promptTokens: Number(totalUsage?.inputTokens ?? 0),
+        completionTokens: Number(totalUsage?.outputTokens ?? 0)
+      };
+      yield {
+        type: "done",
+        finalOutput: finalText || null
+      };
+    } catch (e) {
+      if (signal.aborted) throw new AbortError();
+      throw e;
+    }
+  }
+  dispose() {
+    this.sessionApprovals.clear();
+    this.model = null;
+    super.dispose();
+  }
+};
+var VercelAIAgentService = class {
+  name = "vercel-ai";
+  disposed = false;
+  options;
+  constructor(options) {
+    this.options = options;
+  }
+  createAgent(config) {
+    if (this.disposed) throw new DisposedError("VercelAIAgentService");
+    return new VercelAIAgent(config, this.options);
+  }
+  async listModels() {
+    if (this.disposed) throw new DisposedError("VercelAIAgentService");
+    return [];
+  }
+  async validate() {
+    if (this.disposed) throw new DisposedError("VercelAIAgentService");
+    const errors = [];
+    if (!this.options.apiKey) {
+      errors.push("apiKey is required for Vercel AI backend.");
+    }
+    try {
+      await loadSDK();
+    } catch (e) {
+      errors.push(e instanceof Error ? e.message : String(e));
+    }
+    try {
+      await loadCompat();
+    } catch (e) {
+      errors.push(e instanceof Error ? e.message : String(e));
+    }
+    return { valid: errors.length === 0, errors };
+  }
+  async dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+  }
+};
+function createVercelAIService(options) {
+  return new VercelAIAgentService(options);
+}
+
+export { _injectCompat, _injectSDK, _resetSDK, createVercelAIService };
+//# sourceMappingURL=vercel-ai.js.map
+//# sourceMappingURL=vercel-ai.js.map