@pencil-agent/nano-pencil 2.0.0-beta.2 → 2.0.0-beta.3

package/dist/node_modules/@pencil-agent/agent-core/dist/types.d.ts

@@ -0,0 +1,417 @@
+/**
+ * [WHO]: AgentLoopFramework, AgentLoopTransition, AgentRunResult with transition history, AgentModelErrorRecoveryResult, AgentLoopConfig, CustomAgentMessages, AgentState, AgentToolResult, AgentTool, AgentToolConcurrencySafety, AgentToolInterruptBehavior
+ * [FROM]: No external dependencies
+ * [TO]: Consumed by core/lib/agent-core/src/index.ts
+ * [HERE]: core/lib/agent-core/src/types.ts -
+ */
+import type { AssistantMessageEvent, ImageContent, Message, Model, SimpleStreamOptions, TextContent, Tool, ToolResultMessage, Usage } from "@pencil-agent/ai/types";
+import type { streamSimple } from "@pencil-agent/ai/stream";
+import type { Static, TSchema } from "@pencil-agent/ai/schema";
+/** Stream function - can return sync or Promise for async config lookup */
+export type StreamFn = (...args: Parameters<typeof streamSimple>) => ReturnType<typeof streamSimple> | Promise<ReturnType<typeof streamSimple>>;
+export type AgentLoopFramework = "standard" | "weak-model-compatible";
+export type AgentLoopFrameworkInput = AgentLoopFramework | "high-intelligence" | "low-intelligence" | "structured-adaptive";
+export type AgentLoopTransition = {
+    reason: "start";
+} | {
+    reason: "tool_result";
+    toolCallCount: number;
+} | {
+    reason: "follow_up";
+} | {
+    reason: "max_turns_reached";
+    maxTurns: number;
+    turnCount: number;
+} | {
+    reason: "tool_call_limit_reached";
+    maxToolCalls: number;
+    requestedToolCalls: number;
+    toolCallCount: number;
+} | {
+    reason: "stop_hook_limit_reached";
+    maxContinuations: number;
+    continuationCount: number;
+} | {
+    reason: "max_output_tokens_recovery";
+    attempt: number;
+} | {
+    reason: "stop_hook_blocking";
+    continuationCount: number;
+} | {
+    reason: "model_error_recovery";
+    subtype: string;
+    attempt: number;
+} | {
+    reason: "token_budget_continuation";
+    continuationCount: number;
+    outputTokens: number;
+    targetTokens: number;
+};
+export interface AgentRunResult {
+    stopReason: string;
+    loopFramework?: AgentLoopFramework;
+    loopPolicy?: AgentRunPolicy;
+    turnCount: number;
+    toolCallCount: number;
+    durationMs: number;
+    usage?: Usage;
+    permissionDenialCount?: number;
+    permissionDenials?: AgentToolPermissionDenial[];
+    transitions?: AgentLoopTransition[];
+    lastTransition?: AgentLoopTransition;
+    errorMessage?: string;
+    errorSubtype?: string;
+}
+export interface AgentRunPolicy {
+    maxModelErrorRecoveryAttempts?: number;
+    maxOutputTokenRecoveryAttempts?: number;
+    outputTokenBudget?: {
+        targetTokens: number;
+        thresholdPct?: number;
+        maxContinuations?: number;
+    };
+    maxStopHookContinuations?: number;
+    maxToolConcurrency?: number;
+    maxToolResultBatchSizeChars?: number;
+    maxTurnsPerPrompt?: number;
+    maxToolCallsPerPrompt?: number;
+}
+export declare function normalizeAgentLoopFramework(value: AgentLoopFrameworkInput | undefined): AgentLoopFramework | undefined;
+export type AgentToolPermissionDecision = {
+    decision: "allow";
+} | {
+    decision: "deny";
+    reason?: string;
+};
+export interface AgentToolPermissionDenial {
+    toolCallId: string;
+    toolName: string;
+    reason?: string;
+}
+export type AgentModelErrorRecoveryResult = {
+    action: "stop";
+} | {
+    action: "retry";
+    messages: AgentMessage[];
+    transition?: AgentLoopTransition;
+};
+/**
+ * Configuration for the agent loop.
+ */
+export interface AgentLoopConfig extends SimpleStreamOptions {
+    model: Model<any>;
+    loopFramework?: AgentLoopFrameworkInput;
+    /**
+     * Converts AgentMessage[] to LLM-compatible Message[] before each LLM call.
+     *
+     * Each AgentMessage must be converted to a UserMessage, AssistantMessage, or ToolResultMessage
+     * that the LLM can understand. AgentMessages that cannot be converted (e.g., UI-only notifications,
+     * status messages) should be filtered out.
+     *
+     * @example
+     * ```typescript
+     * convertToLlm: (messages) => messages.flatMap(m => {
+     *   if (m.role === "custom") {
+     *     // Convert custom message to user message
+     *     return [{ role: "user", content: m.content, timestamp: m.timestamp }];
+     *   }
+     *   if (m.role === "notification") {
+     *     // Filter out UI-only messages
+     *     return [];
+     *   }
+     *   // Pass through standard LLM messages
+     *   return [m];
+     * })
+     * ```
+     */
+    convertToLlm: (messages: AgentMessage[]) => Message[] | Promise<Message[]>;
+    /**
+     * Optional transform applied to the context before `convertToLlm`.
+     *
+     * Use this for operations that work at the AgentMessage level:
+     * - Context window management (pruning old messages)
+     * - Injecting context from external sources
+     *
+     * @example
+     * ```typescript
+     * transformContext: async (messages) => {
+     *   if (estimateTokens(messages) > MAX_TOKENS) {
+     *     return pruneOldMessages(messages);
+     *   }
+     *   return messages;
+     * }
+     * ```
+     */
+    transformContext?: (messages: AgentMessage[], signal?: AbortSignal) => Promise<AgentMessage[]>;
+    /**
+     * Resolves an API key dynamically for each LLM call.
+     *
+     * Useful for short-lived OAuth tokens (e.g., GitHub Copilot) that may expire
+     * during long-running tool execution phases.
+     */
+    getApiKey?: (provider: string) => Promise<string | undefined> | string | undefined;
+    /**
+     * Returns steering messages to inject into the conversation mid-run.
+     *
+     * Called after each tool execution to check for user interruptions.
+     * If messages are returned, remaining tool calls are skipped and
+     * these messages are added to the context before the next LLM call.
+     *
+     * Use this for "steering" the agent while it's working.
+     */
+    getSteeringMessages?: () => Promise<AgentMessage[]>;
+    /**
+     * Returns follow-up messages to process after the agent would otherwise stop.
+     *
+     * Called when the agent has no more tool calls and no steering messages.
+     * If messages are returned, they're added to the context and the agent
+     * continues with another turn.
+     *
+     * Use this for follow-up messages that should wait until the agent finishes.
+     */
+    getFollowUpMessages?: () => Promise<AgentMessage[]>;
+    /**
+     * Optional tool permission gate for agent loop tool execution.
+     *
+     * Called after schema/custom validation and before the tool executes.
+     * Return "deny" to feed a permission-denied tool_result back to the model
+     * without crashing the loop.
+     */
+    canUseTool?: (event: {
+        toolCallId: string;
+        toolName: string;
+        requestedToolName: string;
+        input: unknown;
+        rawInput: unknown;
+        tool: AgentTool<any>;
+    }) => Promise<AgentToolPermissionDecision> | AgentToolPermissionDecision;
+    /**
+     * Optional in-loop model error recovery hook.
+     *
+     * Hosts can use this to recover from context overflow or transient provider
+     * errors before the loop reaches agent_end. Return retry with a replacement
+     * AgentMessage context to make the next model call use recovered state.
+     */
+    recoverModelError?: (event: {
+        message: AgentMessage;
+        messages: AgentMessage[];
+        errorSubtype: string;
+        attempt: number;
+    }) => Promise<AgentModelErrorRecoveryResult> | AgentModelErrorRecoveryResult;
+    /**
+     * Optional non-blocking summary for completed tool batches.
+     *
+     * The loop starts this after a tool batch finishes. If the summary is
+     * already settled at the start of a later turn, it is emitted as a normal
+     * AgentMessage and included in that model request. If it is still pending,
+     * the model request proceeds without waiting.
+     */
+    createToolUseSummary?: (event: {
+        assistantMessage: AgentMessage;
+        toolResults: ToolResultMessage[];
+        contextMessages: AgentMessage[];
+        messages: AgentMessage[];
+    }) => AgentMessage | undefined | Promise<AgentMessage | undefined>;
+    /**
+     * Maximum model-error recovery retries for one prompt. Defaults to 1.
+     */
+    maxModelErrorRecoveryAttempts?: number;
+    /**
+     * Maximum assistant turns allowed for one prompt/continue loop.
+     *
+     * Prevents runaway model/tool/follow-up cycles from consuming unbounded
+     * tokens when the model keeps asking for tools or queued messages keep the
+     * loop alive.
+     */
+    maxTurnsPerPrompt?: number;
+    /**
+     * Maximum tool calls allowed for one prompt/continue loop.
+     *
+     * The loop stops before executing a batch that would exceed this limit and
+     * emits a controlled assistant error message.
+     */
+    maxToolCallsPerPrompt?: number;
+    /**
+     * Maximum concurrency for one batch of concurrency-safe tool calls in the
+     * weak-model-compatible loop. Defaults to 10.
+     */
+    maxToolConcurrency?: number;
+    /**
+     * Maximum combined text characters from one assistant tool-use batch that
+     * may be fed into the next model request.
+     *
+     * This aggregate guard complements per-tool maxResultSizeChars: it prevents
+     * several individually valid read/search results from flooding the next
+     * context turn. Loops preserve tool_result order and trim the largest
+     * successful results first.
+     */
+    maxToolResultBatchSizeChars?: number;
+    /**
+     * Maximum automatic continuations after a model stops because it hit its
+     * output-token limit. Defaults to 1.
+     */
+    maxOutputTokenRecoveryAttempts?: number;
+    /**
+     * Optional output-token budget target for long-form agent turns.
+     *
+     * If the assistant stops naturally before cumulative output reaches
+     * thresholdPct * targetTokens, the loop injects a meta continuation prompt.
+     * This is distinct from max-output-token recovery: it handles
+     * under-complete answers, not hard length stops.
+     */
+    outputTokenBudget?: {
+        targetTokens: number;
+        thresholdPct?: number;
+        maxContinuations?: number;
+    };
+    /**
+     * Optional stop hook. Called when the assistant would stop without tool
+     * calls. Return action "continue" with messages to force a
+     * correction/validation turn; return "stop" to allow completion.
+     */
+    runStopHooks?: (event: {
+        message: AgentMessage;
+        messages: AgentMessage[];
+    }) => Promise<StructuredAdaptiveStopHookResult> | StructuredAdaptiveStopHookResult;
+    /**
+     * Maximum stop-hook continuation turns for one prompt. Defaults to 3.
+     */
+    maxStopHookContinuations?: number;
+}
+export type StructuredAdaptiveStopHookResult = {
+    action: "stop";
+} | {
+    action: "continue";
+    messages: AgentMessage[];
+    reason?: string;
+};
+/**
+ * Thinking/reasoning level for models that support it.
+ * Note: "xhigh" is only supported by OpenAI gpt-5.1-codex-max, gpt-5.2, gpt-5.2-codex, gpt-5.3, and gpt-5.3-codex models.
+ */
+export type ThinkingLevel = "off" | "minimal" | "low" | "medium" | "high" | "xhigh";
+/**
+ * Extensible interface for custom app messages.
+ * Apps can extend via declaration merging:
+ *
+ * @example
+ * ```typescript
+ * declare module "@pencil-agent/agent-core" {
+ *   interface CustomAgentMessages {
+ *     artifact: ArtifactMessage;
+ *     notification: NotificationMessage;
+ *   }
+ * }
+ * ```
+ */
+export interface CustomAgentMessages {
+}
+/**
+ * AgentMessage: Union of LLM messages + custom messages.
+ * This abstraction allows apps to add custom message types while maintaining
+ * type safety and compatibility with the base LLM messages.
+ */
+export type AgentMessage = Message | CustomAgentMessages[keyof CustomAgentMessages];
+/**
+ * Agent state containing all configuration and conversation data.
+ */
+export interface AgentState {
+    systemPrompt: string;
+    model: Model<any>;
+    thinkingLevel: ThinkingLevel;
+    tools: AgentTool<any>[];
+    messages: AgentMessage[];
+    isStreaming: boolean;
+    streamMessage: AgentMessage | null;
+    pendingToolCalls: Set<string>;
+    lastResult?: AgentRunResult;
+    error?: string;
+}
+export interface AgentToolResult<T> {
+    content: (TextContent | ImageContent)[];
+    details: T;
+    /**
+     * Optional messages appended after the corresponding tool_result messages.
+     * Use this for tool-generated attachments or context updates that should not
+     * interrupt assistant tool_use -> tool_result pairing.
+     */
+    contextMessages?: AgentMessage[];
+}
+export type AgentToolUpdateCallback<T = any> = (partialResult: AgentToolResult<T>) => void;
+export type AgentToolConcurrencySafety<TParameters extends TSchema = TSchema> = boolean | ((params: Static<TParameters>) => boolean);
+export type AgentToolInterruptBehavior<TParameters extends TSchema = TSchema> = "cancel" | "block" | ((params: Static<TParameters>) => "cancel" | "block");
+export interface AgentTool<TParameters extends TSchema = TSchema, TDetails = any> extends Tool<TParameters> {
+    label: string;
+    /** Alternative model-facing names accepted for transcript/tool compatibility. */
+    aliases?: string[];
+    /**
+     * Whether the tool can safely run alongside other concurrency-safe tools.
+     * The weak-model-compatible loop uses this to batch read-only work while keeping
+     * stateful tools such as edit/write/bash serialized.
+     */
+    isConcurrencySafe?: AgentToolConcurrencySafety<TParameters>;
+    interruptBehavior?: AgentToolInterruptBehavior<TParameters>;
+    /** Optional semantic validation after schema validation and before execute. */
+    validateInput?: (params: Static<TParameters>) => void | string | Promise<void | string>;
+    /** Optional maximum text result size enforced by agent loop tool orchestration. */
+    maxResultSizeChars?: number;
+    execute: (toolCallId: string, params: Static<TParameters>, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<TDetails>) => Promise<AgentToolResult<TDetails>>;
+}
+export interface AgentContext {
+    systemPrompt: string;
+    messages: AgentMessage[];
+    tools?: AgentTool<any>[];
+}
+/**
+ * Events emitted by the Agent for UI updates.
+ * These events provide fine-grained lifecycle information for messages, turns, and tool executions.
+ */
+export type AgentEvent = {
+    type: "agent_start";
+} | {
+    type: "agent_end";
+    messages: AgentMessage[];
+} | ({
+    type: "agent_result";
+} & AgentRunResult) | {
+    type: "stream_request_start";
+    model: string;
+    provider: string;
+    api: string;
+    messageCount: number;
+    maxTokens?: number;
+} | {
+    type: "turn_start";
+} | {
+    type: "turn_end";
+    message: AgentMessage;
+    toolResults: ToolResultMessage[];
+} | {
+    type: "message_start";
+    message: AgentMessage;
+} | {
+    type: "message_update";
+    message: AgentMessage;
+    assistantMessageEvent: AssistantMessageEvent;
+} | {
+    type: "message_end";
+    message: AgentMessage;
+} | {
+    type: "tool_execution_start";
+    toolCallId: string;
+    toolName: string;
+    args: any;
+} | {
+    type: "tool_execution_update";
+    toolCallId: string;
+    toolName: string;
+    args: any;
+    partialResult: any;
+} | {
+    type: "tool_execution_end";
+    toolCallId: string;
+    toolName: string;
+    result: any;
+    isError: boolean;
+    durationMs?: number;
+};

package/dist/node_modules/@pencil-agent/agent-core/dist/types.js

@@ -0,0 +1,13 @@
+/**
+ * [WHO]: AgentLoopFramework, AgentLoopTransition, AgentRunResult with transition history, AgentModelErrorRecoveryResult, AgentLoopConfig, CustomAgentMessages, AgentState, AgentToolResult, AgentTool, AgentToolConcurrencySafety, AgentToolInterruptBehavior
+ * [FROM]: No external dependencies
+ * [TO]: Consumed by core/lib/agent-core/src/index.ts
+ * [HERE]: core/lib/agent-core/src/types.ts -
+ */
+export function normalizeAgentLoopFramework(value) {
+    if (value === "high-intelligence")
+        return "standard";
+    if (value === "low-intelligence" || value === "structured-adaptive")
+        return "weak-model-compatible";
+    return value;
+}

package/dist/node_modules/@pencil-agent/agent-core/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@pencil-agent/agent-core",
+  "version": "0.0.1",
+  "description": "General-purpose agent with transport abstraction, state management, and attachment support",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "dependencies": {
+    "@pencil-agent/ai": "0.0.1"
+  },
+  "keywords": [
+    "ai",
+    "agent",
+    "llm",
+    "transport",
+    "state-management",
+    "pencil-agent"
+  ],
+  "author": "nanoPencil Team",
+  "license": "GPL-3.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/O-Pencil/nanoPencil.git"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  }
+}

package/dist/node_modules/@pencil-agent/ai/dist/api-registry.d.ts

@@ -0,0 +1,27 @@
+/**
+ * [WHO]: ApiProvider, registerApiProvider, registerApiProviderLoader, getApiProvider, ensureApiProvider, reset helpers
+ * [FROM]: Depends on core AI stream/model types for provider contracts
+ * [TO]: Consumed by core/lib/ai/src/stream.ts and providers/register-builtins.ts for provider dispatch
+ * [HERE]: core/lib/ai/src/api-registry.ts - provider registry plus runtime lazy-loader registry
+ */
+import type { Api, AssistantMessageEventStreamContract, Context, Model, SimpleStreamOptions, StreamFunction, StreamOptions } from "./types.js";
+export type ApiStreamFunction = (model: Model<Api>, context: Context, options?: StreamOptions) => AssistantMessageEventStreamContract;
+export type ApiStreamSimpleFunction = (model: Model<Api>, context: Context, options?: SimpleStreamOptions) => AssistantMessageEventStreamContract;
+export interface ApiProvider<TApi extends Api = Api, TOptions extends StreamOptions = StreamOptions> {
+    api: TApi;
+    stream: StreamFunction<TApi, TOptions>;
+    streamSimple: StreamFunction<TApi, SimpleStreamOptions>;
+}
+export interface ApiProviderInternal {
+    api: Api;
+    stream: ApiStreamFunction;
+    streamSimple: ApiStreamSimpleFunction;
+}
+export type ApiProviderLoader<TApi extends Api = Api, TOptions extends StreamOptions = StreamOptions> = () => Promise<ApiProvider<TApi, TOptions>>;
+export declare function registerApiProvider<TApi extends Api, TOptions extends StreamOptions>(provider: ApiProvider<TApi, TOptions>, sourceId?: string): void;
+export declare function registerApiProviderLoader<TApi extends Api, TOptions extends StreamOptions>(api: TApi, loader: ApiProviderLoader<TApi, TOptions>, sourceId?: string): void;
+export declare function getApiProvider(api: Api): ApiProviderInternal | undefined;
+export declare function ensureApiProvider(api: Api): Promise<ApiProviderInternal | undefined>;
+export declare function getApiProviders(): ApiProviderInternal[];
+export declare function unregisterApiProviders(sourceId: string): void;
+export declare function clearApiProviders(): void;

package/dist/node_modules/@pencil-agent/ai/dist/api-registry.js

@@ -0,0 +1,152 @@
+/**
+ * [WHO]: ApiProvider, registerApiProvider, registerApiProviderLoader, getApiProvider, ensureApiProvider, reset helpers
+ * [FROM]: Depends on core AI stream/model types for provider contracts
+ * [TO]: Consumed by core/lib/ai/src/stream.ts and providers/register-builtins.ts for provider dispatch
+ * [HERE]: core/lib/ai/src/api-registry.ts - provider registry plus runtime lazy-loader registry
+ */
+import { AssistantMessageEventStream } from "./utils/event-stream.js";
+const apiProviderRegistry = new Map();
+const apiProviderLoaders = new Map();
+function wrapStream(api, stream) {
+    return (model, context, options) => {
+        if (model.api !== api) {
+            throw new Error(`Mismatched api: ${model.api} expected ${api}`);
+        }
+        return stream(model, context, options);
+    };
+}
+function wrapStreamSimple(api, streamSimple) {
+    return (model, context, options) => {
+        if (model.api !== api) {
+            throw new Error(`Mismatched api: ${model.api} expected ${api}`);
+        }
+        return streamSimple(model, context, options);
+    };
+}
+function emptyUsage() {
+    return {
+        input: 0,
+        output: 0,
+        cacheRead: 0,
+        cacheWrite: 0,
+        totalTokens: 0,
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+    };
+}
+function getErrorMessage(error) {
+    if (error instanceof Error)
+        return error.message;
+    if (typeof error === "string")
+        return error;
+    return JSON.stringify(error) ?? String(error);
+}
+function createProviderLoadErrorMessage(model, error) {
+    return {
+        role: "assistant",
+        content: [],
+        api: model.api,
+        provider: model.provider,
+        model: model.id,
+        stopReason: "error",
+        errorMessage: getErrorMessage(error),
+        usage: emptyUsage(),
+        timestamp: Date.now(),
+    };
+}
+function createMissingProviderResultMessage(model) {
+    return createProviderLoadErrorMessage(model, new Error("Provider stream ended without a final assistant message"));
+}
+function createLazyProvider(api) {
+    return {
+        api,
+        stream: (model, context, options) => {
+            const stream = new AssistantMessageEventStream();
+            void pipeLazyProviderStream(api, model, context, options, stream, "stream");
+            return stream;
+        },
+        streamSimple: (model, context, options) => {
+            const stream = new AssistantMessageEventStream();
+            void pipeLazyProviderStream(api, model, context, options, stream, "streamSimple");
+            return stream;
+        },
+    };
+}
+async function pipeLazyProviderStream(api, model, context, options, output, method) {
+    try {
+        const provider = await ensureApiProvider(api);
+        if (!provider) {
+            throw new Error(`No API provider registered for api: ${api}`);
+        }
+        const source = method === "stream"
+            ? provider.stream(model, context, options)
+            : provider.streamSimple(model, context, options);
+        for await (const event of source) {
+            output.push(event);
+        }
+        if (!source.resultIfResolved()) {
+            output.push({ type: "error", reason: "error", error: createMissingProviderResultMessage(model) });
+        }
+    }
+    catch (error) {
+        output.push({ type: "error", reason: "error", error: createProviderLoadErrorMessage(model, error) });
+    }
+}
+export function registerApiProvider(provider, sourceId) {
+    apiProviderRegistry.set(provider.api, {
+        provider: {
+            api: provider.api,
+            stream: wrapStream(provider.api, provider.stream),
+            streamSimple: wrapStreamSimple(provider.api, provider.streamSimple),
+        },
+        sourceId,
+    });
+}
+export function registerApiProviderLoader(api, loader, sourceId) {
+    apiProviderLoaders.set(api, { loader, sourceId });
+    apiProviderRegistry.set(api, {
+        provider: createLazyProvider(api),
+        sourceId,
+        lazy: true,
+    });
+}
+export function getApiProvider(api) {
+    return apiProviderRegistry.get(api)?.provider;
+}
+export async function ensureApiProvider(api) {
+    const entry = apiProviderRegistry.get(api);
+    if (entry && !entry.lazy)
+        return entry.provider;
+    const loader = apiProviderLoaders.get(api);
+    if (!loader)
+        return entry?.provider;
+    loader.pending ??= loader
+        .loader()
+        .then((provider) => {
+        registerApiProvider(provider, loader.sourceId);
+        return getApiProvider(api);
+    })
+        .finally(() => {
+        loader.pending = undefined;
+    });
+    await loader.pending;
+    return getApiProvider(api);
+}
+export function getApiProviders() {
+    return Array.from(apiProviderRegistry.values(), (entry) => entry.provider);
+}
+export function unregisterApiProviders(sourceId) {
+    for (const [api, entry] of apiProviderRegistry.entries()) {
+        if (entry.sourceId === sourceId) {
+            apiProviderRegistry.delete(api);
+        }
+    }
+    for (const [api, entry] of apiProviderLoaders.entries()) {
+        if (entry.sourceId === sourceId) {
+            apiProviderLoaders.delete(api);
+        }
+    }
+}
+export function clearApiProviders() {
+    apiProviderRegistry.clear();
+    apiProviderLoaders.clear();
+}

package/dist/node_modules/@pencil-agent/ai/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};