@infinityi/engine-lib 1.0.0

package/dist/index-jp2b31xs.js

@@ -0,0 +1,101 @@
+import {
+  createToolRegistry,
+  runAgent
+} from "./index-pwr8179t.js";
+import {
+  s
+} from "./index-02s1fjxr.js";
+import {
+  AgentError,
+  ExecutionError
+} from "./index-7690reng.js";
+import {
+  defineTool
+} from "./index-w34cbktd.js";
+
+// src/agent/define.ts
+function defineAgent(def) {
+  if (typeof def.name !== "string" || def.name.trim() === "") {
+    throw new TypeError("defineAgent: `name` must be a non-empty string");
+  }
+  createToolRegistry(def.tools ?? []);
+  return def;
+}
+// src/agent/agent-registry.ts
+function createAgentRegistry(agents = []) {
+  const byName = new Map;
+  const ordered = [];
+  const register = (agent) => {
+    if (byName.has(agent.name)) {
+      throw new ExecutionError(`duplicate agent name: "${agent.name}"`);
+    }
+    byName.set(agent.name, agent);
+    ordered.push(agent);
+  };
+  for (const agent of agents)
+    register(agent);
+  return {
+    get size() {
+      return ordered.length;
+    },
+    has(name) {
+      return byName.has(name);
+    },
+    get(name) {
+      return byName.get(name);
+    },
+    resolve(name) {
+      const agent = byName.get(name);
+      if (agent === undefined) {
+        throw new ExecutionError(`unknown agent: "${name}"`);
+      }
+      return agent;
+    },
+    list() {
+      return [...ordered];
+    },
+    register
+  };
+}
+// src/agent/as-tool.ts
+var DEFAULT_PARAMETERS = s.object({ input: s.string() });
+function childDepth(event) {
+  return event.type === "agent.child" ? event.depth + 1 : 1;
+}
+function asTool(agent, opts = {}) {
+  const parameters = opts.parameters ?? DEFAULT_PARAMETERS;
+  const toInput = opts.toInput ?? ((args) => args.input);
+  return defineTool({
+    name: opts.name ?? agent.name,
+    description: opts.description ?? `Delegate the task to the "${agent.name}" agent.`,
+    parameters,
+    execute: async (args, ctx) => {
+      const bridge = ctx.run;
+      try {
+        const result = await runAgent(agent, {
+          input: toInput(args),
+          ...ctx.telemetry !== undefined ? { telemetry: ctx.telemetry } : {},
+          ...ctx.logger !== undefined ? { logger: ctx.logger } : {},
+          ...ctx.signal !== undefined ? { signal: ctx.signal } : {},
+          ...bridge !== undefined ? {
+            onEvent: (event) => bridge.emit({
+              type: "agent.child",
+              agent: agent.name,
+              depth: childDepth(event),
+              event
+            })
+          } : {}
+        });
+        bridge?.reportUsage(result.usage);
+        return { ok: true, content: result.output };
+      } catch (err) {
+        if (err instanceof AgentError && err.usage !== undefined) {
+          bridge?.reportUsage(err.usage);
+        }
+        const message = err instanceof AgentError ? err.message : String(err);
+        return { ok: false, error: message };
+      }
+    }
+  });
+}
+export { defineAgent, createAgentRegistry, asTool };

package/dist/index-jxgj4z08.js

@@ -0,0 +1,68 @@
+// src/events/subscribers.ts
+function loggingSubscriber(logger, opts = {}) {
+  const level = opts.level ?? "debug";
+  return (event) => {
+    logger[level](`agent.run ${event.type}`, eventFields(event));
+  };
+}
+function messageBusSubscriber(bus, opts = {}) {
+  const prefix = opts.typePrefix ?? "agent.";
+  return async (event) => {
+    await bus.publish({ type: `${prefix}${event.type}`, payload: eventPayload(event) });
+  };
+}
+function eventFields(event) {
+  switch (event.type) {
+    case "run.start":
+      return { agent: event.agent };
+    case "message":
+      return { role: event.message.role, parts: event.message.content.length };
+    case "token":
+      return { length: event.delta.length };
+    case "tool.call":
+      return { id: event.id, name: event.name };
+    case "tool.result":
+      return { id: event.id, name: event.name, ok: event.result.ok };
+    case "run.finish":
+      return {
+        finishReason: event.result.finishReason,
+        steps: event.result.steps,
+        totalTokens: event.result.usage.totalTokens
+      };
+    case "error":
+      return { name: event.error.name, message: event.error.message };
+    case "agent.child":
+      return { agent: event.agent, depth: event.depth, child: event.event.type };
+    case "agent.handoff":
+      return { from: event.from, to: event.to };
+  }
+}
+function eventPayload(event) {
+  switch (event.type) {
+    case "run.start":
+      return { agent: event.agent };
+    case "message":
+      return { message: event.message };
+    case "token":
+      return { delta: event.delta };
+    case "tool.call":
+      return { id: event.id, name: event.name, arguments: event.arguments };
+    case "tool.result":
+      return { id: event.id, name: event.name, result: event.result };
+    case "run.finish":
+      return {
+        output: event.result.output,
+        finishReason: event.result.finishReason,
+        steps: event.result.steps,
+        usage: event.result.usage,
+        messages: event.result.messages
+      };
+    case "error":
+      return { name: event.error.name, message: event.error.message };
+    case "agent.child":
+      return { agent: event.agent, depth: event.depth, event: eventPayload(event.event) };
+    case "agent.handoff":
+      return { from: event.from, to: event.to };
+  }
+}
+export { loggingSubscriber, messageBusSubscriber, eventFields, eventPayload };

package/dist/index-pwr8179t.js

@@ -0,0 +1,492 @@
+import {
+  applyContextWindow,
+  resolveContext
+} from "./index-yrqrxwjt.js";
+import {
+  SPAN_PROVIDER,
+  SPAN_RUN,
+  SPAN_TOOL,
+  createEventHub,
+  createRunTelemetry
+} from "./index-fkr3rcq9.js";
+import {
+  s
+} from "./index-02s1fjxr.js";
+import {
+  StreamAccumulator
+} from "./index-zfgr4xx3.js";
+import {
+  AgentError,
+  CancelledError,
+  ExecutionError,
+  MaxHandoffsExceededError,
+  MaxStepsExceededError
+} from "./index-7690reng.js";
+import {
+  toProviderTool,
+  toToolResultMessage
+} from "./index-rentvdpp.js";
+import {
+  system,
+  user
+} from "./index-1p6mb2vz.js";
+
+// src/agent/registry.ts
+function createToolRegistry(tools) {
+  const byName = new Map;
+  const ordered = [];
+  for (const tool of tools) {
+    if (byName.has(tool.name)) {
+      throw new ExecutionError(`duplicate tool name: "${tool.name}"`);
+    }
+    byName.set(tool.name, tool);
+    ordered.push(tool);
+  }
+  return {
+    get size() {
+      return ordered.length;
+    },
+    has(name) {
+      return byName.has(name);
+    },
+    get(name) {
+      return byName.get(name);
+    },
+    list() {
+      return ordered;
+    },
+    toProviderTools() {
+      return ordered.map(toProviderTool);
+    }
+  };
+}
+
+// src/agent/handoff.ts
+var HANDOFF_TOOL_PREFIX = "transfer_to_";
+function handoffToolName(agentName) {
+  return `${HANDOFF_TOOL_PREFIX}${agentName}`;
+}
+var HANDOFF_PARAMETERS = s.object({}).jsonSchema;
+function resolveHandoffTargets(agent, registry) {
+  const targets = new Map;
+  for (const entry of agent.handoffs ?? []) {
+    const target = typeof entry === "string" ? resolveByName(agent, entry, registry) : entry;
+    const toolName = handoffToolName(target.name);
+    if (targets.has(toolName)) {
+      throw new ExecutionError(`agent "${agent.name}" declares duplicate handoff target "${target.name}"`);
+    }
+    targets.set(toolName, target);
+  }
+  return targets;
+}
+function resolveByName(agent, name, registry) {
+  if (registry === undefined) {
+    throw new ExecutionError(`agent "${agent.name}" declares a string handoff "${name}" but no registry was ` + `provided; pass { registry } to runAgent or use a direct AgentDefinition target`);
+  }
+  return registry.resolve(name);
+}
+function handoffProviderTools(targets) {
+  return [...targets.entries()].map(([toolName, target]) => ({
+    name: toolName,
+    description: `Transfer the conversation to the "${target.name}" agent. ` + `Use this when the request is better handled by that agent; ` + `the full message history is preserved.`,
+    parameters: HANDOFF_PARAMETERS
+  }));
+}
+
+// src/execution/usage.ts
+function emptyUsage() {
+  return { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
+}
+function addUsage(a, b) {
+  if (b === undefined)
+    return a;
+  const reasoningTokens = a.reasoningTokens !== undefined || b.reasoningTokens !== undefined ? (a.reasoningTokens ?? 0) + (b.reasoningTokens ?? 0) : undefined;
+  const cachedInputTokens = a.cachedInputTokens !== undefined || b.cachedInputTokens !== undefined ? (a.cachedInputTokens ?? 0) + (b.cachedInputTokens ?? 0) : undefined;
+  return {
+    inputTokens: a.inputTokens + b.inputTokens,
+    outputTokens: a.outputTokens + b.outputTokens,
+    totalTokens: a.totalTokens + b.totalTokens,
+    ...reasoningTokens !== undefined ? { reasoningTokens } : {},
+    ...cachedInputTokens !== undefined ? { cachedInputTokens } : {}
+  };
+}
+
+// src/execution/run.ts
+var DEFAULT_MAX_STEPS = 16;
+var DEFAULT_MAX_HANDOFFS = 8;
+function normalizeInput(input) {
+  if (input === undefined)
+    return [];
+  if (typeof input === "string")
+    return [user(input)];
+  if (Array.isArray(input))
+    return input;
+  return [input];
+}
+function extractText(message) {
+  return message.content.filter((p) => p.type === "text").map((p) => p.text).join("");
+}
+function toAgentError(err) {
+  if (err instanceof AgentError)
+    return err;
+  const message = err instanceof Error ? err.message : String(err);
+  return new ExecutionError(message, err instanceof Error ? { cause: err } : undefined);
+}
+function buildEngineContext(opts) {
+  return {
+    ...opts.telemetry !== undefined ? { telemetry: opts.telemetry } : {},
+    ...opts.logger !== undefined ? { logger: opts.logger } : {},
+    ...opts.signal !== undefined ? { signal: opts.signal } : {}
+  };
+}
+function buildRequest(agent, opts, providerTools, messages) {
+  const gen = { ...agent.generation, ...opts.generation };
+  return {
+    messages,
+    ...gen.model !== undefined ? { model: gen.model } : {},
+    ...providerTools !== undefined ? { tools: providerTools } : {},
+    ...gen.toolChoice !== undefined ? { toolChoice: gen.toolChoice } : {},
+    ...gen.temperature !== undefined ? { temperature: gen.temperature } : {},
+    ...gen.topP !== undefined ? { topP: gen.topP } : {},
+    ...gen.maxOutputTokens !== undefined ? { maxOutputTokens: gen.maxOutputTokens } : {},
+    ...gen.stopSequences !== undefined ? { stopSequences: gen.stopSequences } : {}
+  };
+}
+async function resolveInstructions(agent, engineCtx) {
+  const instr = agent.instructions;
+  if (instr === undefined)
+    return;
+  if (typeof instr === "string")
+    return instr;
+  const ctx = { ...engineCtx, agent };
+  return instr(ctx);
+}
+function throwIfAborted(signal) {
+  if (signal?.aborted)
+    throw new CancelledError("run cancelled");
+}
+async function* executeAgent(agent, opts, tel) {
+  const maxSteps = opts.maxSteps ?? DEFAULT_MAX_STEPS;
+  const maxHandoffs = opts.maxHandoffs ?? DEFAULT_MAX_HANDOFFS;
+  const stream = opts.stream === true;
+  const engineCtx = buildEngineContext(opts);
+  const activate = (agentDef) => {
+    const registry = createToolRegistry(agentDef.tools ?? []);
+    const handoffs = resolveHandoffTargets(agentDef, opts.registry);
+    for (const toolName of handoffs.keys()) {
+      if (registry.has(toolName)) {
+        throw new ExecutionError(`agent "${agentDef.name}" has a tool named "${toolName}" that collides with a handoff target`);
+      }
+    }
+    const advertised = [...registry.toProviderTools(), ...handoffProviderTools(handoffs)];
+    return {
+      agent: agentDef,
+      registry,
+      handoffs,
+      providerTools: advertised.length > 0 ? advertised : undefined
+    };
+  };
+  let active = activate(agent);
+  const runOneTool = async (call) => {
+    const events = [];
+    let usage2 = emptyUsage();
+    const bridge = {
+      emit: (event) => events.push(event),
+      reportUsage: (u) => {
+        usage2 = addUsage(usage2, u);
+      }
+    };
+    const tool = active.registry.get(call.name);
+    if (tool === undefined) {
+      return { result: { ok: false, error: `unknown tool: "${call.name}"` }, events, usage: usage2 };
+    }
+    const parsed = tool.parameters.safeParse(call.arguments);
+    if (!parsed.success) {
+      const detail = parsed.error.issues.map((issue) => `${issue.path.join(".") || "<root>"}: ${issue.message}`).join("; ");
+      return {
+        result: { ok: false, error: `invalid arguments for "${call.name}": ${detail}` },
+        events,
+        usage: usage2
+      };
+    }
+    const toolCtx = {
+      ...engineCtx,
+      toolCallId: call.id,
+      agentName: active.agent.name,
+      run: bridge
+    };
+    const span = tel.startSpan(SPAN_TOOL, { "tool.name": call.name, "tool.call_id": call.id });
+    const startedAt = Date.now();
+    try {
+      const result = await tool.execute(parsed.data, toolCtx);
+      span.setAttributes({ "tool.ok": result.ok });
+      span.ok();
+      return { result, events, usage: usage2 };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      span.fail(message);
+      return { result: { ok: false, error: message }, events, usage: usage2 };
+    } finally {
+      span.end();
+      tel.recordTool({ "tool.name": call.name, "agent.name": active.agent.name }, Date.now() - startedAt);
+    }
+  };
+  let usage = emptyUsage();
+  try {
+    throwIfAborted(opts.signal);
+    yield { type: "run.start", agent: agent.name };
+    const instructions = await resolveInstructions(agent, engineCtx);
+    const contextMessages = await resolveContext(opts.context, engineCtx);
+    const prior = opts.session !== undefined ? await opts.session.messages() : opts.messages ?? [];
+    const inputMessages = normalizeInput(opts.input);
+    const messages = [];
+    if (instructions !== undefined && instructions !== "")
+      messages.push(system(instructions));
+    messages.push(...contextMessages);
+    messages.push(...prior);
+    messages.push(...inputMessages);
+    const newMessages = [...inputMessages];
+    await active.agent.hooks?.onStart?.({ agent: active.agent, messages: [...messages] }, engineCtx);
+    let finishReason = "stop";
+    let finalMessage = { role: "assistant", content: [] };
+    let steps = 0;
+    const handoffTrail = [];
+    while (steps < maxSteps) {
+      throwIfAborted(opts.signal);
+      steps++;
+      const provider = active.agent.provider;
+      const model = opts.generation?.model ?? active.agent.generation?.model ?? provider.defaultModel;
+      const requestMessages = await applyContextWindow(messages, opts.contextWindow, {
+        provider,
+        model,
+        engine: engineCtx
+      });
+      const req = buildRequest(active.agent, opts, active.providerTools, requestMessages);
+      const useStreaming = stream && provider.capabilities.streaming;
+      const providerSpan = tel.startSpan(SPAN_PROVIDER, {
+        "provider.name": provider.name,
+        "provider.model": model,
+        "provider.mode": useStreaming ? "stream" : "complete",
+        "agent.step": steps
+      });
+      let result;
+      try {
+        if (useStreaming) {
+          const acc = new StreamAccumulator;
+          let streamError;
+          for await (const event of provider.stream(req, engineCtx)) {
+            acc.push(event);
+            if (event.type === "text_delta" && event.text !== "") {
+              yield { type: "token", delta: event.text };
+            } else if (event.type === "error") {
+              streamError = event.error;
+            }
+          }
+          if (streamError !== undefined)
+            throw streamError;
+          result = acc.result(model);
+        } else {
+          result = await provider.complete(req, engineCtx);
+          if (stream) {
+            const buffered = extractText(result.message);
+            if (buffered !== "")
+              yield { type: "token", delta: buffered };
+          }
+        }
+        providerSpan.setAttributes({ "provider.finish_reason": result.finishReason });
+        providerSpan.ok();
+      } catch (err) {
+        providerSpan.fail(err instanceof Error ? err.message : String(err));
+        throw err;
+      } finally {
+        providerSpan.end();
+      }
+      usage = addUsage(usage, result.usage);
+      finishReason = result.finishReason;
+      finalMessage = result.message;
+      messages.push(result.message);
+      newMessages.push(result.message);
+      yield { type: "message", message: result.message };
+      await active.agent.hooks?.onStep?.({ step: steps, result }, engineCtx);
+      const calls = result.toolCalls;
+      if (calls.length === 0) {
+        const output = extractText(finalMessage);
+        const runResult = {
+          output,
+          finalMessage,
+          messages: [...messages],
+          finishReason,
+          steps,
+          usage,
+          agent: active.agent.name,
+          handoffs: [...handoffTrail]
+        };
+        await opts.session?.append(newMessages);
+        yield { type: "run.finish", result: runResult };
+        await active.agent.hooks?.onFinish?.({ output, usage }, engineCtx);
+        return runResult;
+      }
+      const handoffTargets = active.handoffs;
+      const regularCalls = calls.filter((call) => !handoffTargets.has(call.name));
+      const handoffCalls = calls.filter((call) => handoffTargets.has(call.name));
+      for (const call of calls) {
+        yield { type: "tool.call", id: call.id, name: call.name, arguments: call.arguments };
+        const tool = active.registry.get(call.name);
+        if (tool !== undefined)
+          await active.agent.hooks?.onToolCall?.({ call, tool }, engineCtx);
+      }
+      const settled = await Promise.all(regularCalls.map(async (call) => ({ call, outcome: await runOneTool(call) })));
+      for (const { outcome } of settled)
+        usage = addUsage(usage, outcome.usage);
+      throwIfAborted(opts.signal);
+      for (const { call, outcome } of settled) {
+        for (const childEvent of outcome.events)
+          yield childEvent;
+        const toolResult = outcome.result;
+        yield { type: "tool.result", id: call.id, name: call.name, result: toolResult };
+        await active.agent.hooks?.onToolResult?.({ call, result: toolResult }, engineCtx);
+      }
+      for (const { call, outcome } of settled) {
+        const message = toToolResultMessage(call.id, outcome.result);
+        messages.push(message);
+        newMessages.push(message);
+        yield { type: "message", message };
+      }
+      for (const call of handoffCalls) {
+        const target = handoffTargets.get(call.name);
+        if (target === undefined)
+          continue;
+        if (handoffTrail.length >= maxHandoffs) {
+          throw new MaxHandoffsExceededError(`exceeded max handoffs (${maxHandoffs})`, {
+            handoffs: maxHandoffs
+          });
+        }
+        const ack = { ok: true, content: `Transferred to "${target.name}".` };
+        const ackMessage = toToolResultMessage(call.id, ack);
+        messages.push(ackMessage);
+        newMessages.push(ackMessage);
+        yield { type: "tool.result", id: call.id, name: call.name, result: ack };
+        yield { type: "message", message: ackMessage };
+        const from = active.agent;
+        yield { type: "agent.handoff", from: from.name, to: target.name };
+        await from.hooks?.onHandoff?.({ from, to: target }, engineCtx);
+        active = activate(target);
+        handoffTrail.push(target.name);
+        const nextInstructions = await resolveInstructions(active.agent, engineCtx);
+        if (nextInstructions !== undefined && nextInstructions !== "") {
+          messages.push(system(nextInstructions));
+        }
+      }
+    }
+    throw new MaxStepsExceededError(`exceeded max steps (${maxSteps})`, { steps: maxSteps });
+  } catch (err) {
+    const agentError = toAgentError(err);
+    if (agentError.usage === undefined)
+      agentError.usage = usage;
+    yield { type: "error", error: agentError };
+    try {
+      await active.agent.hooks?.onError?.({ error: agentError }, engineCtx);
+    } catch {}
+    throw agentError;
+  }
+}
+function usageOfError(err) {
+  return err instanceof AgentError && err.usage !== undefined ? err.usage : emptyUsage();
+}
+function runResultAttrs(result) {
+  return {
+    "agent.steps": result.steps,
+    "agent.finish_reason": result.finishReason,
+    "agent.usage.total_tokens": result.usage.totalTokens
+  };
+}
+async function driveToCompletion(gen, hub, tel, agentName) {
+  const startedAt = Date.now();
+  try {
+    const result = await tel.withSpan(SPAN_RUN, { "agent.name": agentName }, async (span) => {
+      let next = await gen.next();
+      while (!next.done) {
+        await hub.emit(next.value);
+        next = await gen.next();
+      }
+      span.setAttributes(runResultAttrs(next.value));
+      span.ok();
+      return next.value;
+    });
+    tel.recordRun({ "agent.name": agentName, "agent.outcome": "ok" }, Date.now() - startedAt, result.usage);
+    return result;
+  } catch (err) {
+    tel.recordRun({ "agent.name": agentName, "agent.outcome": "error" }, Date.now() - startedAt, usageOfError(err));
+    throw err;
+  }
+}
+function makeHandle(gen, hub, tel, agentName) {
+  let resolveCompleted;
+  let rejectCompleted;
+  const completed = new Promise((resolve, reject) => {
+    resolveCompleted = resolve;
+    rejectCompleted = reject;
+  });
+  completed.catch(() => {});
+  const span = tel.startSpan(SPAN_RUN, { "agent.name": agentName });
+  const startedAt = Date.now();
+  async function* iterate() {
+    let settled = false;
+    try {
+      let next = await gen.next();
+      while (!next.done) {
+        await hub.emit(next.value);
+        yield next.value;
+        next = await gen.next();
+      }
+      span.setAttributes(runResultAttrs(next.value));
+      span.ok();
+      settled = true;
+      tel.recordRun({ "agent.name": agentName, "agent.outcome": "ok" }, Date.now() - startedAt, next.value.usage);
+      resolveCompleted(next.value);
+    } catch (err) {
+      span.fail(err instanceof Error ? err.message : String(err));
+      settled = true;
+      tel.recordRun({ "agent.name": agentName, "agent.outcome": "error" }, Date.now() - startedAt, usageOfError(err));
+      rejectCompleted(err);
+      throw err;
+    } finally {
+      if (!settled) {
+        const cancelled = new CancelledError("run stream abandoned before completion");
+        await gen.return(undefined).catch(() => {});
+        span.fail(cancelled.message);
+        tel.recordRun({ "agent.name": agentName, "agent.outcome": "incomplete" }, Date.now() - startedAt, emptyUsage());
+        rejectCompleted(cancelled);
+      }
+      span.end();
+    }
+  }
+  const iterator = iterate();
+  return {
+    [Symbol.asyncIterator]: () => iterator,
+    completed
+  };
+}
+function buildEventHub(opts) {
+  const logger = opts.logger ?? opts.telemetry?.log;
+  return createEventHub({
+    subscribers: [opts.onEvent, ...opts.subscribers ?? []],
+    onSubscriberError: (error, event, index) => {
+      logger?.warn("agent.run subscriber threw", {
+        event: event.type,
+        index,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  });
+}
+function runAgent(agent, opts = {}) {
+  const tel = createRunTelemetry(opts.telemetry);
+  const hub = buildEventHub(opts);
+  const gen = executeAgent(agent, opts, tel);
+  if (opts.stream === true)
+    return makeHandle(gen, hub, tel, agent.name);
+  return driveToCompletion(gen, hub, tel, agent.name);
+}
+
+export { createToolRegistry, handoffToolName, resolveHandoffTargets, handoffProviderTools, emptyUsage, addUsage, DEFAULT_MAX_STEPS, DEFAULT_MAX_HANDOFFS, runAgent };

package/dist/index-rentvdpp.js

@@ -0,0 +1,27 @@
+import {
+  text,
+  toolResult
+} from "./index-1p6mb2vz.js";
+
+// src/tools/result.ts
+function renderToolContent(result) {
+  const value = result.ok ? result.content : result.error;
+  if (typeof value === "string")
+    return [text(value)];
+  if (value === undefined || value === null)
+    return [text("")];
+  return [text(JSON.stringify(value))];
+}
+function toToolResultMessage(toolCallId, result) {
+  const content = renderToolContent(result);
+  return result.ok ? toolResult(toolCallId, content) : toolResult(toolCallId, content, { isError: true });
+}
+function toProviderTool(tool) {
+  return {
+    name: tool.name,
+    ...tool.description !== undefined ? { description: tool.description } : {},
+    parameters: tool.parameters.jsonSchema
+  };
+}
+
+export { renderToolContent, toToolResultMessage, toProviderTool };