kernl 0.2.0 → 0.6.0

package/dist/serde/thread.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"thread.d.ts","sourceRoot":"","sources":["../../src/serde/thread.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB;;;;GAIG;AAEH;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,EAAG,KAAc,CAAC;AAQrD,QAAA,MAAM,kBAAkB;;;;;;;;;;;;iBActB,CAAC;AAEH,KAAK,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,GAAG;IAC7D,aAAa,CAAC,EAAE,kBAAkB,CAAC;CACpC,CAAC;AAkHF,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8B3B,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC"}

package/dist/serde/thread.js

@@ -1,158 +0,0 @@
-import { z } from "zod";
-import * as events from "../types/thread";
-/**
- * Utilities and schemas for serializing the run-state so that it can be paused / resumed later.
- *
- * (TODO): should be able to define this as a codec for the ThreadState schema
- */
-/**
- * The schema version of the serialized run state. This is used to ensure that the serialized
- * run state is compatible with the current version of the SDK.
- * If anything in this schema changes, the version will have to be incremented.
- */
-export const CURRENT_SCHEMA_VERSION = "1.0";
-const $schemaVersion = z.literal(CURRENT_SCHEMA_VERSION);
-const serializedAgentSchema = z.object({
-    id: z.string(),
-    name: z.string().optional(),
-});
-const serializedSpanBase = z.object({
-    object: z.literal("trace.span"),
-    id: z.string(),
-    trace_id: z.string(),
-    parent_id: z.string().nullable(),
-    started_at: z.string().nullable(),
-    ended_at: z.string().nullable(),
-    error: z
-        .object({
-        message: z.string(),
-        data: z.record(z.string(), z.any()).optional(),
-    })
-        .nullable(),
-    span_data: z.record(z.string(), z.any()),
-});
-const SerializedSpan = serializedSpanBase.extend({
-    previous_span: z.lazy(() => SerializedSpan).optional(),
-});
-const usageSchema = z.object({
-    requests: z.number(),
-    inputTokens: z.number(),
-    outputTokens: z.number(),
-    totalTokens: z.number(),
-});
-const modelResponseSchema = z.object({
-    usage: usageSchema,
-    events: z.array(events.ThreadEvent),
-    responseId: z.string().optional(),
-    providerData: z.record(z.string(), z.any()).optional(),
-});
-const itemSchema = z.discriminatedUnion("kind", [
-    z.object({
-        kind: z.literal("message"),
-        rawItem: events.AssistantMessage,
-        agent: serializedAgentSchema,
-    }),
-    z.object({
-        kind: z.literal("tool-call"),
-        // rawItem: events.ToolCall.or(events.HostedToolCall),
-        rawItem: events.ToolCall,
-        agent: serializedAgentSchema,
-    }),
-    z.object({
-        kind: z.literal("tool-result"),
-        rawItem: events.ToolResultEvent,
-        agent: serializedAgentSchema,
-        output: z.string(),
-    }),
-    z.object({
-        kind: z.literal("reasoning"),
-        rawItem: events.Reasoning,
-        agent: serializedAgentSchema,
-    }),
-]);
-const serializedTraceSchema = z.object({
-    object: z.literal("trace"),
-    id: z.string(),
-    workflow_name: z.string(),
-    group_id: z.string().nullable(),
-    metadata: z.record(z.string(), z.any()),
-});
-const serializedProcessedResponseSchema = z.object({
-    newItems: z.array(itemSchema),
-    toolsUsed: z.array(z.string()),
-    functions: z.array(z.object({
-        toolCall: z.any(),
-        tool: z.any(),
-    })),
-    mcpApprovalRequests: z
-        .array(z.object({
-        requestItem: z.object({
-            // protocol.HostedToolCallItem
-            rawItem: z.object({
-                type: z.literal("hosted_tool_call"),
-                name: z.string(),
-                arguments: z.string().optional(),
-                status: z.string().optional(),
-                output: z.string().optional(),
-                // this always exists but marked as optional for early version compatibility; when releasing 1.0, we can remove the nullable and optional
-                providerData: z.record(z.string(), z.any()).nullable().optional(),
-            }),
-        }),
-        // HostedMCPTool
-        mcpTool: z.object({
-            type: z.literal("hosted_tool"),
-            name: z.literal("hosted_mcp"),
-            providerData: z.record(z.string(), z.any()),
-        }),
-    }))
-        .optional(),
-});
-const guardrailFunctionOutputSchema = z.object({
-    tripwireTriggered: z.boolean(),
-    outputInfo: z.any(),
-});
-const inputGuardrailResultSchema = z.object({
-    guardrail: z.object({
-        type: z.literal("input"),
-        name: z.string(),
-    }),
-    output: guardrailFunctionOutputSchema,
-});
-const outputGuardrailResultSchema = z.object({
-    guardrail: z.object({
-        type: z.literal("output"),
-        name: z.string(),
-    }),
-    agentOutput: z.any(),
-    agent: serializedAgentSchema,
-    output: guardrailFunctionOutputSchema,
-});
-// (TODO): define z.codec
-export const SerializedThread = z.object({
-    $schemaVersion,
-    currentTurn: z.number(),
-    currentAgent: serializedAgentSchema, // (TODO): in our case we probably don't need to serialize the whole agent - an ID would suffice
-    originalInput: z.string().or(z.array(events.ThreadEvent)),
-    modelResponses: z.array(modelResponseSchema),
-    context: z.object({
-        usage: usageSchema, // (TODO): move to stats
-        // (TODO): belongs elsewhere
-        approvals: z.record(z.string(), z.object({
-            approved: z.array(z.string()).or(z.boolean()),
-            rejected: z.array(z.string()).or(z.boolean()),
-        })),
-        context: z.record(z.string(), z.any()),
-    }),
-    toolUseTracker: z.record(z.string(), z.array(z.string())),
-    maxTurns: z.number(),
-    currentAgentSpan: SerializedSpan.nullable().optional(),
-    noActiveAgentRun: z.boolean(),
-    inputGuardrailResults: z.array(inputGuardrailResultSchema),
-    outputGuardrailResults: z.array(outputGuardrailResultSchema),
-    // (TODO): currentStep: nextStepSchema.optional(),
-    lastModelResponse: modelResponseSchema.optional(),
-    generatedItems: z.array(itemSchema),
-    lastProcessedResponse: serializedProcessedResponseSchema.optional(),
-    currentTurnPersistedItemCount: z.number().int().min(0).optional(),
-    trace: serializedTraceSchema.nullable(),
-});

package/dist/serde/tool.d.ts

@@ -1,36 +0,0 @@
-import type { ToolInputParameters } from "../tool/types";
-/**
- * Serialized function tool for model requests
- */
-export type SerializedFunctionTool = {
-    /**
-     * The type of the tool.
-     */
-    type: "function";
-    /**
-     * The name of the tool.
-     */
-    name?: string;
-    /**
-     * The description of the tool that helps the model to understand when to use the tool
-     */
-    description: string;
-    /**
-     * A JSON schema describing the parameters of the tool.
-     */
-    parameters: ToolInputParameters;
-};
-/**
- * Serialized hosted tool for model requests
- */
-export type SerializedHostedTool = {
-    type: "hosted-tool";
-    id: string;
-    name?: string;
-    providerData?: Record<string, any>;
-};
-/**
- * Union of all serialized tool types
- */
-export type SerializedTool = SerializedFunctionTool | SerializedHostedTool;
-//# sourceMappingURL=tool.d.ts.map

package/dist/serde/tool.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/serde/tool.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAExD;;GAEG;AACH,MAAM,MAAM,sBAAsB,GAAG;IACnC;;OAEG;IACH,IAAI,EAAE,UAAU,CAAC;IAEjB;;OAEG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd;;OAEG;IACH,WAAW,EAAE,MAAM,CAAC;IAEpB;;OAEG;IACH,UAAU,EAAE,mBAAmB,CAAC;CACjC,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAAG;IACjC,IAAI,EAAE,aAAa,CAAC;IACpB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CACpC,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG,sBAAsB,GAAG,oBAAoB,CAAC"}

package/dist/session.d.ts

@@ -1 +0,0 @@
-//# sourceMappingURL=session.d.ts.map

package/dist/session.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../src/session.ts"],"names":[],"mappings":""}

package/dist/session.js

@@ -1 +0,0 @@
-"use strict";

package/dist/thread/__tests__/stream.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=stream.test.d.ts.map

package/dist/thread/__tests__/stream.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"stream.test.d.ts","sourceRoot":"","sources":["../../../src/thread/__tests__/stream.test.ts"],"names":[],"mappings":""}

package/dist/thread/__tests__/stream.test.js

@@ -1,244 +0,0 @@
-import { describe, it, expect, beforeAll } from "vitest";
-import { z } from "zod";
-import { openai } from "@ai-sdk/openai";
-import { AISDKLanguageModel } from "@kernl-sdk/ai";
-import { Agent } from "../../agent";
-import { Kernl } from "../../kernl";
-import { tool, Toolkit } from "../../tool";
-import { Thread } from "../thread";
-/**
- * Integration tests for Thread streaming with real AI SDK providers.
- *
- * These tests require an OPENAI_API_KEY environment variable to be set.
- * They will be skipped if the API key is not available.
- *
- * Run with: OPENAI_API_KEY=your-key pnpm test:run
- */
-const SKIP_INTEGRATION_TESTS = !process.env.OPENAI_API_KEY;
-describe.skipIf(SKIP_INTEGRATION_TESTS)("Thread streaming integration", () => {
-    let kernl;
-    let model;
-    beforeAll(() => {
-        kernl = new Kernl();
-        model = new AISDKLanguageModel(openai("gpt-4o-mini"));
-    });
-    describe("stream()", () => {
-        it("should yield both delta events and complete items", async () => {
-            const agent = new Agent({
-                id: "test-stream",
-                name: "Test Stream Agent",
-                instructions: "You are a helpful assistant.",
-                model,
-            });
-            const input = [
-                {
-                    kind: "message",
-                    id: "msg-1",
-                    role: "user",
-                    content: [
-                        { kind: "text", text: "Say 'Hello World' and nothing else." },
-                    ],
-                },
-            ];
-            const thread = new Thread(kernl, agent, input);
-            const events = [];
-            for await (const event of thread.stream()) {
-                events.push(event);
-            }
-            expect(events.length).toBeGreaterThan(0);
-            // Should have text-delta events (for streaming UX)
-            const textDeltas = events.filter((e) => e.kind === "text-delta");
-            expect(textDeltas.length).toBeGreaterThan(0);
-            // Should have text-start event
-            const textStarts = events.filter((e) => e.kind === "text-start");
-            expect(textStarts.length).toBeGreaterThan(0);
-            // Should have text-end event
-            const textEnds = events.filter((e) => e.kind === "text-end");
-            expect(textEnds.length).toBeGreaterThan(0);
-            // Should have complete Message item (for history)
-            const messages = events.filter((e) => e.kind === "message");
-            expect(messages.length).toBeGreaterThan(0);
-            const assistantMessage = messages.find((m) => m.role === "assistant");
-            expect(assistantMessage).toBeDefined();
-            expect(assistantMessage.content).toBeDefined();
-            expect(assistantMessage.content.length).toBeGreaterThan(0);
-            // Message should have accumulated text from all deltas
-            const textContent = assistantMessage.content.find((c) => c.kind === "text");
-            expect(textContent).toBeDefined();
-            expect(textContent.text).toBeDefined();
-            expect(textContent.text.length).toBeGreaterThan(0);
-            // Verify accumulated text matches concatenated deltas
-            const accumulatedFromDeltas = textDeltas.map((d) => d.text).join("");
-            expect(textContent.text).toBe(accumulatedFromDeltas);
-            // Should have finish event
-            const finishEvents = events.filter((e) => e.kind === "finish");
-            expect(finishEvents.length).toBe(1);
-        });
-        it("should filter deltas from history but include complete items", async () => {
-            const agent = new Agent({
-                id: "test-history",
-                name: "Test History Agent",
-                instructions: "You are a helpful assistant.",
-                model,
-            });
-            const input = [
-                {
-                    kind: "message",
-                    id: "msg-1",
-                    role: "user",
-                    content: [{ kind: "text", text: "Count to 3" }],
-                },
-            ];
-            const thread = new Thread(kernl, agent, input);
-            const streamEvents = [];
-            for await (const event of thread.stream()) {
-                streamEvents.push(event);
-            }
-            // Access private history via type assertion for testing
-            const history = thread.history;
-            // History should only contain complete items (message, reasoning, tool-call, tool-result)
-            // TypeScript already enforces this via ThreadEvent type, but let's verify at runtime
-            for (const event of history) {
-                expect(["message", "reasoning", "tool-call", "tool-result"]).toContain(event.kind);
-            }
-            // Stream events should include deltas (but history should not)
-            const streamDeltas = streamEvents.filter((e) => e.kind === "text-delta" ||
-                e.kind === "text-start" ||
-                e.kind === "text-end");
-            expect(streamDeltas.length).toBeGreaterThan(0);
-            // History should contain the input message
-            expect(history[0]).toEqual(input[0]);
-            // History should contain complete Message items
-            const historyMessages = history.filter((e) => e.kind === "message");
-            expect(historyMessages.length).toBeGreaterThan(1); // input + assistant response
-            // Verify assistant message has complete text (not deltas)
-            const assistantMessage = historyMessages.find((m) => m.role === "assistant");
-            expect(assistantMessage).toBeDefined();
-            const textContent = assistantMessage.content.find((c) => c.kind === "text");
-            expect(textContent.text).toBeTruthy();
-            expect(textContent.text.length).toBeGreaterThan(0);
-        });
-        it("should work with tool calls", async () => {
-            const calculateTool = tool({
-                name: "calculate",
-                description: "Perform a mathematical calculation",
-                parameters: z.object({
-                    expression: z
-                        .string()
-                        .describe("The mathematical expression to evaluate"),
-                }),
-                execute: async (ctx, { expression }) => {
-                    // Simple eval for testing (don't do this in production!)
-                    try {
-                        return { result: eval(expression) };
-                    }
-                    catch {
-                        return { error: "Invalid expression" };
-                    }
-                },
-            });
-            const toolkit = new Toolkit({
-                id: "math",
-                tools: [calculateTool],
-            });
-            const agent = new Agent({
-                id: "test-tools",
-                name: "Test Tools Agent",
-                instructions: "You are a helpful assistant that can do calculations.",
-                model,
-                toolkits: [toolkit],
-            });
-            const input = [
-                {
-                    kind: "message",
-                    id: "msg-1",
-                    role: "user",
-                    content: [{ kind: "text", text: "What is 25 + 17?" }],
-                },
-            ];
-            const thread = new Thread(kernl, agent, input);
-            const events = [];
-            for await (const event of thread.stream()) {
-                events.push(event);
-            }
-            expect(events.length).toBeGreaterThan(0);
-            // Should have tool calls
-            const toolCalls = events.filter((e) => e.kind === "tool-call");
-            expect(toolCalls.length).toBeGreaterThan(0);
-            // Should have tool results
-            const toolResults = events.filter((e) => e.kind === "tool-result");
-            expect(toolResults.length).toBeGreaterThan(0);
-            // History should contain tool calls and results
-            const history = thread.history;
-            const historyToolCalls = history.filter((e) => e.kind === "tool-call");
-            const historyToolResults = history.filter((e) => e.kind === "tool-result");
-            expect(historyToolCalls.length).toBe(toolCalls.length);
-            expect(historyToolResults.length).toBe(toolResults.length);
-        });
-    });
-    describe("execute()", () => {
-        it("should consume stream and return final response", async () => {
-            const agent = new Agent({
-                id: "test-blocking",
-                name: "Test Blocking Agent",
-                instructions: "You are a helpful assistant.",
-                model,
-            });
-            const input = [
-                {
-                    kind: "message",
-                    id: "msg-1",
-                    role: "user",
-                    content: [{ kind: "text", text: "Say 'Testing' and nothing else." }],
-                },
-            ];
-            const thread = new Thread(kernl, agent, input);
-            const result = await thread.execute();
-            // Should have a response
-            expect(result.response).toBeDefined();
-            expect(typeof result.response).toBe("string");
-            expect(result.response.length).toBeGreaterThan(0);
-            // Should have final state
-            expect(result.state).toBe("stopped");
-            // History should NOT contain deltas
-            const history = thread.history;
-            const historyDeltas = history.filter((e) => e.kind === "text-delta" ||
-                e.kind === "text-start" ||
-                e.kind === "text-end");
-            expect(historyDeltas.length).toBe(0);
-        });
-        it("should validate structured output in blocking mode", async () => {
-            const responseSchema = z.object({
-                name: z.string(),
-                age: z.number(),
-            });
-            const agent = new Agent({
-                id: "test-structured",
-                name: "Test Structured Agent",
-                instructions: "You are a helpful assistant. Return JSON with name and age fields.",
-                model,
-                responseType: responseSchema,
-            });
-            const input = [
-                {
-                    kind: "message",
-                    id: "msg-1",
-                    role: "user",
-                    content: [
-                        {
-                            kind: "text",
-                            text: 'Return a JSON object with name "Alice" and age 30',
-                        },
-                    ],
-                },
-            ];
-            const thread = new Thread(kernl, agent, input);
-            const result = await thread.execute();
-            // Response should be validated and parsed
-            expect(result.response).toBeDefined();
-            expect(typeof result.response).toBe("object");
-            expect(result.response.name).toBeTruthy();
-            expect(typeof result.response.age).toBe("number");
-        });
-    });
-});

package/dist/tool/mcp.d.ts

@@ -1,75 +0,0 @@
-import type { Context, UnknownContext } from "../context";
-import { Toolkit } from "./toolkit";
-import type { Tool } from ".";
-import type { MCPToolkitConfig } from "./types";
-/**
- * A toolkit that wraps an MCP server and provides tools from it.
- *
- * Handles connection lifecycle automatically - connects lazily on first tool request
- * and provides cleanup via destroy().
- *
- * @example
- * ```ts
- * const server = new MCPServerStdio({
- *   id: "github",
- *   command: "npx",
- *   args: ["-y", "@modelcontextprotocol/server-github"],
- *   env: {
- *     GITHUB_TOKEN: process.env.GITHUB_TOKEN,
- *   },
- * });
- *
- * const github = new MCPToolkit({
- *   id: "github",
- *   server,
- *   filter: async (ctx, tool) => {
- *     // Only allow certain tools
- *     return !tool.id.startsWith("dangerous_");
- *   },
- * });
- *
- * const agent = new Agent({
- *   toolkits: [github],
- * });
- * ```
- */
-export declare class MCPToolkit<TContext = UnknownContext> extends Toolkit<TContext> {
-    readonly id: string;
-    private server;
-    private cache;
-    private filter;
-    private connected;
-    private cached;
-    /**
-     * Create a new MCP toolkit.
-     *
-     * @param config Toolkit configuration with id and server instance
-     */
-    constructor(config: MCPToolkitConfig<TContext>);
-    /**
-     * Get a specific tool by ID.
-     *
-     * Returns the tool from the local cache. The cache is populated on the first
-     * call to list(). Returns undefined if list() hasn't been called yet.
-     *
-     * @param id The tool ID to look up
-     * @returns The tool if found in cache, undefined otherwise
-     */
-    get(id: string): Tool<TContext> | undefined;
-    /**
-     * List all tools available from the MCP server.
-     *
-     * Connects to the server lazily on first call. Tools are cached locally after
-     * the first fetch. The MCP server itself also handles caching via the
-     * cacheToolsList option, so the network call is only made once.
-     *
-     * @param context Optional context for filtering tools
-     * @returns Array of tools from the MCP server
-     */
-    list(context?: Context<TContext>): Promise<Tool<TContext>[]>;
-    /**
-     * Cleanup resources and close the MCP server connection.
-     */
-    destroy(): Promise<void>;
-}
-//# sourceMappingURL=mcp.d.ts.map

package/dist/tool/mcp.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mcp.d.ts","sourceRoot":"","sources":["../../src/tool/mcp.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAOzD,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,GAAG,CAAC;AAC9B,OAAO,KAAK,EAAE,gBAAgB,EAAiB,MAAM,SAAS,CAAC;AAE/D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,qBAAa,UAAU,CAAC,QAAQ,GAAG,cAAc,CAAE,SAAQ,OAAO,CAAC,QAAQ,CAAC;IAC1E,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,MAAM,CAAY;IAC1B,OAAO,CAAC,KAAK,CAA8B;IAC3C,OAAO,CAAC,MAAM,CAA0B;IAExC,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,MAAM,CAAS;IAEvB;;;;OAIG;gBACS,MAAM,EAAE,gBAAgB,CAAC,QAAQ,CAAC;IAQ9C;;;;;;;;OAQG;IACH,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,SAAS;IAI3C;;;;;;;;;OASG;IACG,IAAI,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC,QAAQ,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC;IA+BlE;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CAQ/B"}

package/dist/tool/mcp.js

@@ -1,111 +0,0 @@
-import { mcpToFunctionTool } from "../mcp/utils";
-import { filter } from "../lib/utils";
-import { Toolkit } from "./toolkit";
-/**
- * A toolkit that wraps an MCP server and provides tools from it.
- *
- * Handles connection lifecycle automatically - connects lazily on first tool request
- * and provides cleanup via destroy().
- *
- * @example
- * ```ts
- * const server = new MCPServerStdio({
- *   id: "github",
- *   command: "npx",
- *   args: ["-y", "@modelcontextprotocol/server-github"],
- *   env: {
- *     GITHUB_TOKEN: process.env.GITHUB_TOKEN,
- *   },
- * });
- *
- * const github = new MCPToolkit({
- *   id: "github",
- *   server,
- *   filter: async (ctx, tool) => {
- *     // Only allow certain tools
- *     return !tool.id.startsWith("dangerous_");
- *   },
- * });
- *
- * const agent = new Agent({
- *   toolkits: [github],
- * });
- * ```
- */
-export class MCPToolkit extends Toolkit {
-    id;
-    server;
-    cache;
-    filter;
-    connected = false;
-    cached = false;
-    /**
-     * Create a new MCP toolkit.
-     *
-     * @param config Toolkit configuration with id and server instance
-     */
-    constructor(config) {
-        super();
-        this.id = config.id;
-        this.server = config.server;
-        this.filter = config.filter ?? (() => true);
-        this.cache = new Map();
-    }
-    /**
-     * Get a specific tool by ID.
-     *
-     * Returns the tool from the local cache. The cache is populated on the first
-     * call to list(). Returns undefined if list() hasn't been called yet.
-     *
-     * @param id The tool ID to look up
-     * @returns The tool if found in cache, undefined otherwise
-     */
-    get(id) {
-        return this.cache.get(id);
-    }
-    /**
-     * List all tools available from the MCP server.
-     *
-     * Connects to the server lazily on first call. Tools are cached locally after
-     * the first fetch. The MCP server itself also handles caching via the
-     * cacheToolsList option, so the network call is only made once.
-     *
-     * @param context Optional context for filtering tools
-     * @returns Array of tools from the MCP server
-     */
-    async list(context) {
-        if (!this.connected) {
-            await this.server.connect();
-            this.connected = true;
-        }
-        // lazy cache population
-        if (!this.cached) {
-            const mcpTools = await this.server.listTools();
-            for (const mcpTool of mcpTools) {
-                const tool = mcpToFunctionTool(this.server, mcpTool);
-                this.cache.set(tool.id, tool);
-            }
-            this.cached = true;
-        }
-        const tools = Array.from(this.cache.values());
-        // apply filter
-        if (context && this.agent) {
-            const ctx = { context, agent: this.agent, toolkitId: this.id };
-            return filter(tools, async (tool) => {
-                return await this.filter(ctx, tool);
-            });
-        }
-        return tools;
-    }
-    /**
-     * Cleanup resources and close the MCP server connection.
-     */
-    async destroy() {
-        if (this.connected) {
-            await this.server.close();
-            this.connected = false;
-            this.cache.clear();
-            this.cached = false;
-        }
-    }
-}