@gugacoder/agentic-sdk 0.2.0

package/dist/proxy.js

@@ -0,0 +1,103 @@
+import { AgentRunOptionsSchema } from "./schemas.js";
+import { runAiAgent } from "./agent.js";
+import { braveSearch } from "./tools/brave-search.js";
+/**
+ * DuckDuckGo HTML search scraper — no API key needed.
+ */
+async function duckDuckGoSearch(query, numResults = 5) {
+    const url = `https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`;
+    const res = await fetch(url, {
+        headers: {
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
+        },
+    });
+    if (!res.ok)
+        return [];
+    const html = await res.text();
+    const results = [];
+    const resultPattern = /<a[^>]*class="result__a"[^>]*href="([^"]*)"[^>]*>([\s\S]*?)<\/a>[\s\S]*?<a[^>]*class="result__snippet"[^>]*>([\s\S]*?)<\/a>/g;
+    let match;
+    while ((match = resultPattern.exec(html)) !== null && results.length < numResults) {
+        const rawUrl = match[1];
+        const title = match[2].replace(/<[^>]+>/g, "").trim();
+        const snippet = match[3].replace(/<[^>]+>/g, "").trim();
+        // DuckDuckGo uses redirect URLs — extract the real URL
+        const realUrl = new URL(rawUrl, "https://duckduckgo.com").searchParams.get("uddg") ?? rawUrl;
+        if (title && snippet) {
+            results.push({ title, url: realUrl, snippet });
+        }
+    }
+    return results;
+}
+/**
+ * Resolve web search provider from providerConfig.
+ * Returns undefined when search is disabled ("none").
+ */
+function resolveSearchProvider(providerConfig) {
+    const provider = providerConfig?.webSearch ?? "duckduckgo";
+    if (provider === "none")
+        return undefined;
+    if (provider === "brave" && providerConfig?.braveApiKey) {
+        return (q, n) => braveSearch(q, n, providerConfig.braveApiKey);
+    }
+    return duckDuckGoSearch;
+}
+export async function* runAgent(raw) {
+    const options = AgentRunOptionsSchema.parse(raw);
+    const startMs = Date.now();
+    const onWebSearch = resolveSearchProvider(options.providerConfig);
+    console.log(`[proxy] model=${options.model} role=${options.role ?? "conversation"} webSearch=${options.providerConfig?.webSearch ?? "duckduckgo"}`);
+    for await (const event of runAiAgent(options.prompt, {
+        model: options.model,
+        apiKey: options.apiKey,
+        provider: options.provider,
+        providers: options.providers,
+        sessionId: options.sessionId,
+        sessionDir: options.sessionDir,
+        messageMeta: options.messageMeta,
+        maxSteps: options.maxTurns ?? 100,
+        ...(onWebSearch ? { onWebSearch } : {}),
+        ...(options.tools ? { tools: options.tools } : {}),
+        ...(options.system ? { system: { append: options.system } } : {}),
+        ...(options.contentParts ? { contentParts: options.contentParts } : {}),
+    })) {
+        if (event.type === "init") {
+            yield { type: "init", sessionId: event.sessionId };
+        }
+        else if (event.type === "text") {
+            yield { type: "text", content: event.content };
+        }
+        else if (event.type === "result") {
+            yield { type: "result", content: event.content };
+        }
+        else if (event.type === "usage") {
+            yield {
+                type: "usage",
+                usage: {
+                    inputTokens: event.usage.inputTokens,
+                    outputTokens: event.usage.outputTokens,
+                    cacheReadInputTokens: event.usage.cacheReadInputTokens,
+                    cacheCreationInputTokens: event.usage.cacheCreationInputTokens,
+                    totalCostUsd: event.usage.totalCostUsd,
+                    numTurns: event.usage.numTurns,
+                    durationMs: event.usage.durationMs || (Date.now() - startMs),
+                    durationApiMs: event.usage.durationApiMs,
+                    stopReason: event.usage.stopReason,
+                },
+            };
+        }
+        else if (event.type === "step_finish") {
+            yield { type: "step_finish" };
+        }
+        else if (event.type === "reasoning") {
+            yield { type: "reasoning", content: event.content };
+        }
+        else if (event.type === "tool-call") {
+            yield { type: "tool-call", toolCallId: event.toolCallId, toolName: event.toolName, args: event.args };
+        }
+        else if (event.type === "tool-result") {
+            yield { type: "tool-result", toolCallId: event.toolCallId, toolName: event.toolName, result: event.result };
+        }
+        // Unknown event types are silently dropped (safe denylist: only known AgentEvent members are forwarded)
+    }
+}

package/dist/schemas.d.ts

@@ -0,0 +1,228 @@
+import { z } from "zod";
+export declare const UsageDataSchema: z.ZodObject<{
+    inputTokens: z.ZodNumber;
+    outputTokens: z.ZodNumber;
+    cacheReadInputTokens: z.ZodDefault<z.ZodNumber>;
+    cacheCreationInputTokens: z.ZodDefault<z.ZodNumber>;
+    totalCostUsd: z.ZodDefault<z.ZodNumber>;
+    numTurns: z.ZodDefault<z.ZodNumber>;
+    durationMs: z.ZodDefault<z.ZodNumber>;
+    durationApiMs: z.ZodDefault<z.ZodNumber>;
+    stopReason: z.ZodDefault<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    inputTokens: number;
+    outputTokens: number;
+    cacheReadInputTokens: number;
+    cacheCreationInputTokens: number;
+    totalCostUsd: number;
+    numTurns: number;
+    durationMs: number;
+    durationApiMs: number;
+    stopReason: string;
+}, {
+    inputTokens: number;
+    outputTokens: number;
+    cacheReadInputTokens?: number | undefined;
+    cacheCreationInputTokens?: number | undefined;
+    totalCostUsd?: number | undefined;
+    numTurns?: number | undefined;
+    durationMs?: number | undefined;
+    durationApiMs?: number | undefined;
+    stopReason?: string | undefined;
+}>;
+export declare const AgentEventSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    type: z.ZodLiteral<"init">;
+    sessionId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: "init";
+    sessionId?: string | undefined;
+}, {
+    type: "init";
+    sessionId?: string | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"text">;
+    content: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "text";
+    content: string;
+}, {
+    type: "text";
+    content: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"step_finish">;
+}, "strip", z.ZodTypeAny, {
+    type: "step_finish";
+}, {
+    type: "step_finish";
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"result">;
+    content: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "result";
+    content: string;
+}, {
+    type: "result";
+    content: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"usage">;
+    usage: z.ZodObject<{
+        inputTokens: z.ZodNumber;
+        outputTokens: z.ZodNumber;
+        cacheReadInputTokens: z.ZodDefault<z.ZodNumber>;
+        cacheCreationInputTokens: z.ZodDefault<z.ZodNumber>;
+        totalCostUsd: z.ZodDefault<z.ZodNumber>;
+        numTurns: z.ZodDefault<z.ZodNumber>;
+        durationMs: z.ZodDefault<z.ZodNumber>;
+        durationApiMs: z.ZodDefault<z.ZodNumber>;
+        stopReason: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        inputTokens: number;
+        outputTokens: number;
+        cacheReadInputTokens: number;
+        cacheCreationInputTokens: number;
+        totalCostUsd: number;
+        numTurns: number;
+        durationMs: number;
+        durationApiMs: number;
+        stopReason: string;
+    }, {
+        inputTokens: number;
+        outputTokens: number;
+        cacheReadInputTokens?: number | undefined;
+        cacheCreationInputTokens?: number | undefined;
+        totalCostUsd?: number | undefined;
+        numTurns?: number | undefined;
+        durationMs?: number | undefined;
+        durationApiMs?: number | undefined;
+        stopReason?: string | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    type: "usage";
+    usage: {
+        inputTokens: number;
+        outputTokens: number;
+        cacheReadInputTokens: number;
+        cacheCreationInputTokens: number;
+        totalCostUsd: number;
+        numTurns: number;
+        durationMs: number;
+        durationApiMs: number;
+        stopReason: string;
+    };
+}, {
+    type: "usage";
+    usage: {
+        inputTokens: number;
+        outputTokens: number;
+        cacheReadInputTokens?: number | undefined;
+        cacheCreationInputTokens?: number | undefined;
+        totalCostUsd?: number | undefined;
+        numTurns?: number | undefined;
+        durationMs?: number | undefined;
+        durationApiMs?: number | undefined;
+        stopReason?: string | undefined;
+    };
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"reasoning">;
+    content: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "reasoning";
+    content: string;
+}, {
+    type: "reasoning";
+    content: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"tool-call">;
+    toolCallId: z.ZodString;
+    toolName: z.ZodString;
+    args: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+    type: "tool-call";
+    args: Record<string, unknown>;
+    toolCallId: string;
+    toolName: string;
+}, {
+    type: "tool-call";
+    args: Record<string, unknown>;
+    toolCallId: string;
+    toolName: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"tool-result">;
+    toolCallId: z.ZodString;
+    toolName: z.ZodString;
+    result: z.ZodUnknown;
+}, "strip", z.ZodTypeAny, {
+    type: "tool-result";
+    toolCallId: string;
+    toolName: string;
+    result?: unknown;
+}, {
+    type: "tool-result";
+    toolCallId: string;
+    toolName: string;
+    result?: unknown;
+}>]>;
+export declare const AgentRunOptionsSchema: z.ZodObject<{
+    model: z.ZodString;
+    apiKey: z.ZodString;
+    prompt: z.ZodString;
+    sessionId: z.ZodOptional<z.ZodString>;
+    sessionDir: z.ZodOptional<z.ZodString>;
+    role: z.ZodOptional<z.ZodString>;
+    tools: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    maxTurns: z.ZodOptional<z.ZodNumber>;
+    providerConfig: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    system: z.ZodOptional<z.ZodString>;
+    messageMeta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    provider: z.ZodOptional<z.ZodString>;
+    providers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        baseURL: z.ZodString;
+        apiKey: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        apiKey: string;
+        baseURL: string;
+    }, {
+        apiKey: string;
+        baseURL: string;
+    }>>>;
+    contentParts: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
+}, "strip", z.ZodTypeAny, {
+    apiKey: string;
+    prompt: string;
+    model: string;
+    provider?: string | undefined;
+    system?: string | undefined;
+    tools?: Record<string, any> | undefined;
+    sessionId?: string | undefined;
+    sessionDir?: string | undefined;
+    role?: string | undefined;
+    maxTurns?: number | undefined;
+    providerConfig?: Record<string, any> | undefined;
+    messageMeta?: Record<string, unknown> | undefined;
+    providers?: Record<string, {
+        apiKey: string;
+        baseURL: string;
+    }> | undefined;
+    contentParts?: any[] | undefined;
+}, {
+    apiKey: string;
+    prompt: string;
+    model: string;
+    provider?: string | undefined;
+    system?: string | undefined;
+    tools?: Record<string, any> | undefined;
+    sessionId?: string | undefined;
+    sessionDir?: string | undefined;
+    role?: string | undefined;
+    maxTurns?: number | undefined;
+    providerConfig?: Record<string, any> | undefined;
+    messageMeta?: Record<string, unknown> | undefined;
+    providers?: Record<string, {
+        apiKey: string;
+        baseURL: string;
+    }> | undefined;
+    contentParts?: any[] | undefined;
+}>;
+export type AgentEvent = z.infer<typeof AgentEventSchema>;
+export type UsageData = z.infer<typeof UsageDataSchema>;
+export type AgentRunOptions = z.infer<typeof AgentRunOptionsSchema>;

package/dist/schemas.js

@@ -0,0 +1,51 @@
+import { z } from "zod";
+// --- Usage ---
+export const UsageDataSchema = z.object({
+    inputTokens: z.number(),
+    outputTokens: z.number(),
+    cacheReadInputTokens: z.number().default(0),
+    cacheCreationInputTokens: z.number().default(0),
+    totalCostUsd: z.number().default(0),
+    numTurns: z.number().default(0),
+    durationMs: z.number().default(0),
+    durationApiMs: z.number().default(0),
+    stopReason: z.string().default("unknown"),
+});
+// --- Events (o que o proxy emite) ---
+export const AgentEventSchema = z.discriminatedUnion("type", [
+    z.object({ type: z.literal("init"), sessionId: z.string().optional() }),
+    z.object({ type: z.literal("text"), content: z.string() }),
+    z.object({ type: z.literal("step_finish") }),
+    z.object({ type: z.literal("result"), content: z.string() }),
+    z.object({ type: z.literal("usage"), usage: UsageDataSchema }),
+    z.object({ type: z.literal("reasoning"), content: z.string() }),
+    z.object({
+        type: z.literal("tool-call"),
+        toolCallId: z.string(),
+        toolName: z.string(),
+        args: z.record(z.unknown()),
+    }),
+    z.object({
+        type: z.literal("tool-result"),
+        toolCallId: z.string(),
+        toolName: z.string(),
+        result: z.unknown(),
+    }),
+]);
+// --- Options (o que o backbone passa) ---
+export const AgentRunOptionsSchema = z.object({
+    model: z.string(),
+    apiKey: z.string(),
+    prompt: z.string(),
+    sessionId: z.string().optional(),
+    sessionDir: z.string().optional(),
+    role: z.string().optional(),
+    tools: z.record(z.any()).optional(),
+    maxTurns: z.number().optional(),
+    providerConfig: z.record(z.any()).optional(),
+    system: z.string().optional(),
+    messageMeta: z.record(z.unknown()).optional(),
+    provider: z.string().optional(),
+    providers: z.record(z.object({ baseURL: z.string(), apiKey: z.string() })).optional(),
+    contentParts: z.array(z.any()).optional(),
+});

package/dist/session.d.ts

@@ -0,0 +1,7 @@
+import type { ModelMessage } from "ai";
+export declare function resolveRefs(content: unknown[], attachmentsDir: string): Promise<unknown[]>;
+export declare function loadSession(dir: string): Promise<ModelMessage[]>;
+export declare function filterOldMedia(messages: ModelMessage[], lastUserIndex: number): ModelMessage[];
+export declare function saveSession(dir: string, messages: (ModelMessage & {
+    _meta?: Record<string, unknown>;
+})[]): Promise<void>;

package/dist/session.js

@@ -0,0 +1,102 @@
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { join, dirname, basename } from "node:path";
+function sessionPath(dir) {
+    return join(dir, "messages.jsonl");
+}
+export async function resolveRefs(content, attachmentsDir) {
+    const resolved = [];
+    for (const part of content) {
+        if (typeof part !== "object" || part === null) {
+            resolved.push(part);
+            continue;
+        }
+        const p = part;
+        if (p._ref && (p.type === "image" || p.type === "file")) {
+            const filename = basename(p._ref);
+            const filePath = join(attachmentsDir, filename);
+            try {
+                const buffer = await readFile(filePath);
+                const base64 = buffer.toString("base64");
+                if (p.type === "image") {
+                    resolved.push({ type: "image", image: base64, mimeType: p.mimeType, _ref: p._ref });
+                }
+                else {
+                    resolved.push({ type: "file", data: base64, mimeType: p.mimeType, _ref: p._ref });
+                }
+            }
+            catch {
+                resolved.push({ type: "text", text: `[arquivo removido: ${filename}]` });
+            }
+        }
+        else {
+            resolved.push(part);
+        }
+    }
+    return resolved;
+}
+export async function loadSession(dir) {
+    try {
+        const content = await readFile(sessionPath(dir), "utf-8");
+        const messages = content
+            .split("\n")
+            .filter((line) => line.trim())
+            .map((line) => {
+            const { _meta, ...msg } = JSON.parse(line);
+            return msg;
+        });
+        const attachmentsDir = join(dir, "attachments");
+        const result = [];
+        for (const msg of messages) {
+            if (Array.isArray(msg.content)) {
+                const resolvedContent = await resolveRefs(msg.content, attachmentsDir);
+                result.push({ ...msg, content: resolvedContent });
+            }
+            else {
+                result.push(msg);
+            }
+        }
+        return result;
+    }
+    catch {
+        return [];
+    }
+}
+export function filterOldMedia(messages, lastUserIndex) {
+    return messages.map((msg, i) => {
+        if (msg.role !== "user" || i === lastUserIndex) {
+            return msg;
+        }
+        if (!Array.isArray(msg.content)) {
+            return msg;
+        }
+        const filtered = msg.content.map((part) => {
+            if (typeof part !== "object" || part === null)
+                return part;
+            const p = part;
+            if (p.type === "image") {
+                const name = p._ref ?? "imagem";
+                return { type: "text", text: `[imagem enviada: ${name}]` };
+            }
+            if (p.type === "file" && p.data !== undefined) {
+                const name = p._ref ?? "arquivo";
+                return { type: "text", text: `[arquivo enviado: ${name}]` };
+            }
+            return part;
+        });
+        return { ...msg, content: filtered };
+    });
+}
+export async function saveSession(dir, messages) {
+    const filePath = sessionPath(dir);
+    await mkdir(dirname(filePath), { recursive: true });
+    const ts = new Date().toISOString();
+    const jsonl = messages
+        .map((m) => {
+        if (!m._meta) {
+            return JSON.stringify({ ...m, _meta: { ts } });
+        }
+        return JSON.stringify(m);
+    })
+        .join("\n") + "\n";
+    await writeFile(filePath, jsonl, "utf-8");
+}

package/dist/structured.d.ts

@@ -0,0 +1,18 @@
+import type { z } from "zod";
+import type { createAiProviderRegistry } from "./providers.js";
+export interface AiObjectOptions<T extends z.ZodType> {
+    model: string;
+    apiKey: string;
+    /** Provider name (e.g. "openrouter", "groq"). Default: "openrouter" */
+    provider?: string;
+    /** Base URL override for the provider */
+    baseURL?: string;
+    schema: T;
+    system?: string;
+    prompt: string;
+    maxTokens?: number;
+    /** Provider registry para reuso. Se nao fornecido, cria um internamente (backward compat). */
+    providers?: ReturnType<typeof createAiProviderRegistry>;
+}
+export declare function aiGenerateObject<T extends z.ZodType>(options: AiObjectOptions<T>): Promise<z.infer<T>>;
+export declare function aiStreamObject<T extends z.ZodType>(options: AiObjectOptions<T>): AsyncGenerator<Partial<z.infer<T>>>;

package/dist/structured.js

@@ -0,0 +1,38 @@
+import { generateText, streamObject, Output } from "ai";
+import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
+export async function aiGenerateObject(options) {
+    const model = options.providers
+        ? options.providers.model(options.model, options.provider)
+        : createOpenAICompatible({
+            name: options.provider ?? "openrouter",
+            baseURL: options.baseURL ?? "https://openrouter.ai/api/v1",
+            apiKey: options.apiKey,
+        })(options.model);
+    const result = await generateText({
+        model,
+        output: Output.object({ schema: options.schema }),
+        system: options.system,
+        prompt: options.prompt,
+        maxOutputTokens: options.maxTokens,
+    });
+    return result.output;
+}
+export async function* aiStreamObject(options) {
+    const model = options.providers
+        ? options.providers.model(options.model, options.provider)
+        : createOpenAICompatible({
+            name: options.provider ?? "openrouter",
+            baseURL: options.baseURL ?? "https://openrouter.ai/api/v1",
+            apiKey: options.apiKey,
+        })(options.model);
+    const result = streamObject({
+        model,
+        schema: options.schema,
+        system: options.system,
+        prompt: options.prompt,
+        maxOutputTokens: options.maxTokens,
+    });
+    for await (const partial of result.partialObjectStream) {
+        yield partial;
+    }
+}

package/dist/tool-repair.d.ts

@@ -0,0 +1,21 @@
+import type { LanguageModel } from "ai";
+import type { LanguageModelV3ToolCall } from "@ai-sdk/provider";
+export interface RepairContext {
+    model: LanguageModel;
+    maxAttempts: number;
+}
+/**
+ * Cria um handler de reparo que pede ao modelo para corrigir a tool call.
+ * Primeiro tenta corrigir o nome da tool (case mismatch), depois os args.
+ * Tenta N vezes. Se todas falharem, retorna null (deixa o erro original propagar).
+ */
+export declare function createToolCallRepairHandler(ctx: RepairContext): (options: {
+    toolCall: LanguageModelV3ToolCall;
+    tools: Record<string, unknown>;
+    inputSchema: (opts: {
+        toolName: string;
+    }) => unknown;
+    error: Error;
+    system?: unknown;
+    messages?: unknown;
+}) => Promise<LanguageModelV3ToolCall | null>;

package/dist/tool-repair.js

@@ -0,0 +1,72 @@
+import { generateText } from "ai";
+/**
+ * Try to fix tool name by case-insensitive matching against available tools.
+ * Returns the correct name if found, or null.
+ */
+function fixToolName(toolName, tools) {
+    if (toolName in tools)
+        return toolName; // already correct
+    const lower = toolName.toLowerCase();
+    for (const name of Object.keys(tools)) {
+        if (name.toLowerCase() === lower)
+            return name;
+    }
+    return null;
+}
+/**
+ * Cria um handler de reparo que pede ao modelo para corrigir a tool call.
+ * Primeiro tenta corrigir o nome da tool (case mismatch), depois os args.
+ * Tenta N vezes. Se todas falharem, retorna null (deixa o erro original propagar).
+ */
+export function createToolCallRepairHandler(ctx) {
+    const attempts = new Map();
+    return async (options) => {
+        const { toolCall, tools, inputSchema, error } = options;
+        // Fix tool name case mismatch (e.g. "Email_send" → "email_send")
+        const correctedName = fixToolName(toolCall.toolName, tools);
+        if (correctedName && correctedName !== toolCall.toolName) {
+            return {
+                type: "tool-call",
+                toolCallId: toolCall.toolCallId,
+                toolName: correctedName,
+                input: toolCall.input,
+            };
+        }
+        const key = `${toolCall.toolName}:${toolCall.input}`;
+        const current = attempts.get(key) ?? 0;
+        if (current >= ctx.maxAttempts) {
+            return null; // desiste — erro original propaga
+        }
+        attempts.set(key, current + 1);
+        // If tool name is completely wrong, can't repair args
+        if (!correctedName)
+            return null;
+        try {
+            const schema = await Promise.resolve(inputSchema({ toolName: toolCall.toolName }));
+            const result = await generateText({
+                model: ctx.model,
+                system: [
+                    "You generated an invalid tool call. Fix the JSON arguments to match the schema.",
+                    "Return ONLY the corrected JSON object — no explanation, no markdown.",
+                ].join("\n"),
+                prompt: [
+                    `Tool: ${toolCall.toolName}`,
+                    `Schema: ${JSON.stringify(schema)}`,
+                    `Invalid args: ${toolCall.input}`,
+                    `Error: ${error.message}`,
+                ].join("\n"),
+                maxOutputTokens: 1000,
+            });
+            const repaired = (result.text ?? toolCall.input).trim();
+            return {
+                type: "tool-call",
+                toolCallId: toolCall.toolCallId,
+                toolName: toolCall.toolName,
+                input: repaired,
+            };
+        }
+        catch {
+            return null; // reparo falhou — erro original propaga
+        }
+    };
+}

package/dist/tools/api-spec.d.ts

@@ -0,0 +1,4 @@
+export declare const apiSpecTool: import("ai").Tool<{
+    url: string;
+    format: "auto" | "openapi";
+}, string>;