@prismshadow/penguin-core 0.0.1

package/dist/interfaces-CMSN7-pO.d.ts

@@ -0,0 +1,487 @@
+import { O as OmniMessage, S as StopReason, T as ToolDefinition, a as ToolCallPayload, A as ApprovalDecision } from './types-D6FERSdT.js';
+
+/** Foreground process exit info. At most one of `code`/`signal` is set (consistent with Node child's exit event). */
+interface ProcessExit {
+    code: number | null;
+    signal: NodeJS.Signals | null;
+}
+/** Arguments required to start a command. */
+interface SpawnOptions {
+    /** Command string handed to `bash -lc`. */
+    cmd: string;
+    /** Working directory (absolute path). */
+    cwd: string;
+    /** Child process environment variables (the caller has already injected hardening entries like PAGER/TERM). */
+    env: NodeJS.ProcessEnv;
+}
+declare class ManagedSession {
+    /** Timestamp of the last access (used for LRU / idle reaping). */
+    lastUsed: number;
+    private readonly child;
+    private readonly buffer;
+    private exited;
+    private exitInfo;
+    private spawnError;
+    private killed;
+    private killTimer;
+    private readonly wakeSignal;
+    constructor(opts: SpawnOptions);
+    /** Signals the process group; ignores the case where the process/group has already exited (ESRCH). */
+    private signalGroup;
+    private handleData;
+    private handleExit;
+    private handleError;
+    /** Whether the command is still running (hasn't exited, spawn hasn't failed). */
+    get running(): boolean;
+    get exit(): ProcessExit | null;
+    get error(): Error | null;
+    /**
+     * Streams output deltas within `yieldMs` (data is yielded as soon as it arrives). Once done,
+     * the terminal state is determined via `running`/`exit`/`error`:
+     * - Exits mid-window -> the trailing output is yielded along with it (extra ≤POST_EXIT_DRAIN_MS drain);
+     * - Still running once the window expires -> whatever output exists is yielded and collection ends, with the process switching to background;
+     * - `signal` aborts -> whatever output exists is yielded and collection ends immediately (the process isn't killed; the caller decides whether to keep it).
+     */
+    collect(yieldMs: number, signal?: AbortSignal): AsyncGenerator<string>;
+    write(chars: string): void;
+    interrupt(): void;
+    /** Closes out: sends SIGTERM to the process group, then SIGKILL after a grace period (reaping leftover background child processes); idempotent. */
+    kill(): void;
+    /** Synchronous hard kill (process 'exit' fallback: the event loop has already stopped at this point, so timers aren't available). */
+    killHard(): void;
+}
+
+/**
+ * CommandSessionManager — registry and lifecycle management for long-running command sessions.
+ *
+ * Constructed by Environment (one per Session), injected via services and shared by the
+ * `exec_command` and `input_command` tools. Registry responsibilities (id allocation, concurrency
+ * cap, dispose, process 'exit' fallback) are handled by the generic `BackgroundRegistry` (shared
+ * with subagent sessions, see `../background/registry.ts`); this class only retains
+ * command-domain logic: spawning processes and assembling the child process environment (vault
+ * injection + hardening).
+ * Docs: /docs/tools § "Background session caps".
+ */
+
+declare class CommandSessionManager {
+    private readonly registry;
+    /** Agent vault environment variables: injected into the child process on every spawn (values never enter the model context, only the environment). */
+    private readonly vault;
+    constructor(opts?: {
+        vault?: Record<string, string>;
+    });
+    /** Starts a command, returning an **unregistered** session (no process_id yet). */
+    spawn(opts: {
+        cmd: string;
+        cwd: string;
+    }): ManagedSession;
+    /** Registers a still-running session as a background process, allocating and returning a unique `process_id`. */
+    register(session: ManagedSession): string;
+    /** Looks up a session by process_id and refreshes its access time; returns undefined if it doesn't exist. */
+    get(processId: string): ManagedSession | undefined;
+    /** Removes from the registry and cleans up the process group (called after the session exits). */
+    remove(processId: string): void;
+    /** Disposes: removes the fallback registration and kills all sessions (the process 'exit' fallback is hooked up by the registry itself). Idempotent. */
+    dispose(): void;
+}
+
+/**
+ * ManagedSubagentSession — a subagent session capable of running in the background.
+ *
+ * Holds a `SubagentHandle` and drives its `run` (pump): the same child Session may run across
+ * multiple rounds (the first round is initiated by `run_subagent`, later rounds append a Prompt
+ * via `input_subagent`). Structurally mirrors a command session (ManagedSession): the parent tool
+ * call collects output live within the yield window; output produced outside the window (while
+ * running in the background) goes into a buffer, delivered all at once on the next access.
+ *
+ * Three kinds of output, each with its own destination:
+ * - **Message buffer**: all of the child session's OmniMessage (already tagged with origin), for
+ *   the parent tool call to forward to the frontend for rendering; capped in count, overflow
+ *   drops the oldest (only affects frontend replay — the child Session's own Trace loses no
+ *   data);
+ * - **Text buffer**: assistant text deltas from the direct child layer (origin one hop), fed back
+ *   as the parent tool's own output to the LLM; capped in capacity (prevents memory bloat),
+ *   overflow drops the oldest with a marker;
+ * - **Approval queue**: the child session's tool approval requests. While running in the
+ *   background, the parent session may have no active tool call to forward approval through, so
+ *   the request is queued and the child session blocks waiting; the parent tool call
+ *   (run_subagent / input_subagent) attaches an approval sink (`attachApprovalSink`) within its
+ *   window to consult Human one request at a time — if detached mid-consultation (window ends),
+ *   the request stays queued, and a late-arriving decision still takes effect (settled guard,
+ *   first to arrive wins).
+ *
+ * Cleanup: `kill()` aborts the current run via AbortSignal, denies all pending approvals, and
+ * releases child Session resources; idempotent. The child Session runs in-process, so there's no
+ * need for a separate synchronous hard-kill path (its command sessions are reaped by their own
+ * exit fallback); `killHard` is equivalent to `kill`.
+ */
+
+/** Terminal state of one run. */
+interface SubagentExit {
+    status: "completed" | "failed";
+    note?: string;
+}
+declare class ManagedSubagentSession {
+    /** Timestamp of the last access (used for the eviction policy). */
+    lastUsed: number;
+    private readonly handle;
+    private readonly abortCtrl;
+    private messages;
+    private readonly textBuffer;
+    private isRunning;
+    private exitInfo;
+    private killed;
+    private readonly approvals;
+    private sink;
+    private sinkEpoch;
+    private pumpingApprovals;
+    private readonly wakeSignal;
+    constructor(handle: SubagentHandle);
+    /** Child Session id (one hop of a message's origin); `subagent_id` is derived from its tail so the frontend can correlate it. */
+    get sessionId(): string;
+    /** Whether a round of the task is currently running. */
+    get running(): boolean;
+    /** Terminal state of the most recent run; null if no round has ever completed. */
+    get exit(): SubagentExit | null;
+    /** Number of pending approval requests (the parent tool uses this to hint the model to poll again). */
+    get pendingApprovals(): number;
+    /** Whether there's unread output (buffered messages or text); used to re-check the predicate before waiting (see collect.ts). */
+    get hasPending(): boolean;
+    /**
+     * Starts a new round of the task on the child Session (async pump, doesn't block the caller).
+     * Throws if already disposed or still running (converted to an explanatory output by the
+     * caller).
+     */
+    startRun(prompt: string): void;
+    /** Takes the buffered child-session messages (already tagged with origin, for the parent tool to forward). */
+    drainMessages(): OmniMessage[];
+    /** Takes the currently unread child Agent text (including the drop marker); clears the buffer. */
+    drainText(): string;
+    /** External wakeup (e.g. the parent tool call was aborted): makes a waiting `waitWake` return immediately. */
+    wakeup(): void;
+    /** Waits for "woken up" or `ms` to expire, whichever comes first. */
+    waitWake(ms: number): Promise<void>;
+    /**
+     * Attaches an approval sink: the parent tool call active within the window hands in its own
+     * `ctx.approve`, and queued approval requests are consulted with Human through it one at a
+     * time. Returns a detach function (called when the window ends); a later attach replaces the
+     * former one.
+     */
+    attachApprovalSink(approve: ApproveFn): () => void;
+    /** Cleanup: aborts the current run, denies pending approvals, releases child Session resources; idempotent. */
+    kill(): void;
+    /** Synchronous hard-kill path: the child Session runs in-process with no separate OS resources, so this is equivalent to `kill`. */
+    killHard(): void;
+    /** Drives one round of `handle.run`: buffers messages and text, settling the terminal state when it ends. */
+    private pump;
+    private bufferMessage;
+    private appendText;
+    /** Approval callback handed to the child Session: the request is queued and waits for some parent tool call to consult Human and give a decision. */
+    private readonly childApprove;
+    /** Settles an approval decision: first to arrive wins, late/duplicate decisions are ignored. */
+    private settle;
+    /**
+     * Hands the request at the head of the queue to the currently attached approval sink, one at a
+     * time. Stops when the window ends (the sink is detached); unresolved requests stay queued for
+     * the next sink; if a consultation already in flight resolves late, the decision still takes
+     * effect via settle.
+     */
+    private pumpApprovals;
+}
+
+declare class SubagentSessionManager {
+    private readonly registry;
+    /** Whether the manager has been disposed (the host Session has ended). */
+    get isDisposed(): boolean;
+    /** Whether there's still room for a new background session (evicting a completed, idle one if needed; never evicts a running one). */
+    makeRoom(): boolean;
+    /**
+     * Registers a still-running session as a background session, allocating and returning a
+     * unique `subagent_id`: `subagent-<last 8 hex of child Session id>` (falls back to random on
+     * collision), whose suffix aligns with the message origin/frontend nesting label
+     * (`agent-<last 3 chars>`) for correlation.
+     */
+    register(session: ManagedSubagentSession): string;
+    /** Looks up a session by subagent_id and refreshes its access time; returns undefined if not found. */
+    get(subagentId: string): ManagedSubagentSession | undefined;
+    /** Disposes: removes the fallback registration and finalizes all sessions (the process 'exit' fallback is hooked by the registry itself). Idempotent. */
+    dispose(): void;
+}
+
+/**
+ * Session-level uniqueness for tool_call_id.
+ *
+ * Some providers don't produce a real call id: e.g. Gemini's functionCall has no id, so AgentHub
+ * uses the **function name** as the `tool_call_id` — consecutive/parallel calls to the same tool then
+ * all share one id. But the OmniMessage world (engine dispatch/pairing, approval routing, frontend
+ * tool-card attribution) keys on `tool_call_id`, and a collision lets a later call overwrite the
+ * earlier one (parallel same-name calls in one turn can even be dropped entirely).
+ *
+ * Approach: inbound, `EventTranslator` disambiguates duplicate ids with a `#n` suffix (the first keeps
+ * the original id); outbound (returning tool_result, replaying history on resume) uses
+ * `stripToolCallIdSuffix` to strip the suffix and restore the original — Gemini's functionResponse
+ * pairs by using `tool_call_id` as the name, so it must be restored to the function name. The registry
+ * lives at Session level (the new GenerativeModel rebuilt on compaction shares the same instance), and
+ * on resume `setHistory` seeds it with historical ids, so the uniqueness scope covers the entire
+ * context the frontend renders.
+ * Docs: /docs/interfaces § "The built-in implementation: GenerativeModel".
+ */
+declare class ToolCallIdAllocator {
+    /** OmniMessage-level tool_call_ids already taken in this Session (history-seeded + allocated). */
+    private used;
+    /** Register an already-used id (for resume seeding); registering twice is harmless. */
+    markUsed(id: string): void;
+    /**
+     * Allocate a Session-unique id for a provider-reported tool_call_id: if unused, keep the original;
+     * if already used (a repeat call from a name-as-id provider), take the first free `origId#n` (n from 2).
+     * Providers with truly unique ids (OpenAI `call_*` / Claude `toolu_*`) never collide, so they pass through unchanged.
+     */
+    allocate(providerId: string): string;
+}
+/**
+ * Strip the `#n` suffix added by `allocate`, restoring the provider's original id (returns as-is when
+ * there's no suffix; idempotent). On resume there's no registry to compare against, so it trims by
+ * shape: real ids from known providers (OpenAI/Claude `call_*`/`toolu_*`, Gemini function names — `#`
+ * isn't a valid function-name char) never end in `#<digits>`, so they aren't harmed.
+ */
+declare function stripToolCallIdSuffix(id: string): string;
+
+/**
+ * Internal SDK interface contracts: LLM, Environment.
+ *
+ * `context_engine` only handles OmniMessage; protocol conversion and concrete implementations
+ * are each interface's own responsibility.
+ * Human is not an "interface/class with methods" but the SDK's input/output boundary itself:
+ * output is streamed by `Session.run()` as an async generator, and input is delivered via
+ * `run`'s `RunOptions` — approvals are requested one at a time through the injected `approve`
+ * callback, and interruption goes through `signal`. Hence no Human interface is defined here.
+ *
+ * These types form the foundational contract shared by all units; implementing units integrate
+ * against them.
+ *
+ * Docs: packages/docs/content/interfaces.{zh,en}.md (site path /docs/interfaces) explains each
+ * contract and its extension seams — keep the page in sync when changing signatures here.
+ */
+
+/** Tool permission: read-only / read-write. */
+type ToolPermission = "r" | "rw";
+/**
+ * Runtime configuration for a single tool.
+ * Docs: /docs/tools § "Configuration fields".
+ */
+interface ToolDefinitionConfig {
+    name: string;
+    description: string;
+    parameters?: Record<string, unknown>;
+    permission?: ToolPermission;
+    /**
+     * Which class of session model this entry targets: `"vision"` only for models that support
+     * images (e.g. read_image), `"text-only"` only for text-only models (e.g. describe_image);
+     * omitted means available for all models. Filtered by session model at assembly time
+     * (see `selectBuiltinToolsForModel`).
+     */
+    forModel?: "vision" | "text-only";
+    /** Timeout for a single tool call (ms); on timeout, ends as `failed`; <=0 disables it. */
+    timeoutMs?: number;
+    /** Max length of tool output; Environment truncates from the front (keeping the head) if exceeded; <=0 disables it. */
+    maxOutputLength?: number;
+}
+interface MCPServerConfig {
+    name: string;
+    config: Record<string, unknown>;
+}
+/** Set of tool configs required to initialize Environment. */
+interface ToolConfig {
+    customTools: ToolDefinitionConfig[];
+    mcpServers: MCPServerConfig[];
+}
+/**
+ * Per-tool approval callback: the Human boundary gives allow/deny for each complete `tool_call`.
+ * `context_engine` calls it once per tool call within a turn. Subagents forward the parent's
+ * approval callback, so the child Agent **inherits the parent Agent's approval mode**.
+ * Docs: /docs/interfaces § "ApproveFn".
+ */
+type ApproveFn = (toolCall: OmniMessage<ToolCallPayload>) => Promise<ApprovalDecision>;
+type ThinkingLevelName = "none" | "low" | "medium" | "high" | "xhigh";
+/**
+ * GenerativeModel initialization config.
+ * Docs: /docs/interfaces § "GenerativeModelConfig".
+ */
+interface GenerativeModelConfig {
+    modelId: string;
+    apiKey?: string;
+    baseUrl?: string;
+    /**
+     * AgentHub client protocol (`openai` / `claude-4-8` / `deepseek-v4` / …). If omitted, AgentHub
+     * infers it from `modelId`; custom-named models or third-party models using the OpenAI protocol
+     * must specify it explicitly.
+     */
+    clientType?: string;
+    tools: ToolDefinition[];
+    /** Full system Prompt after placeholder substitution in the system_config.system_prompt template. */
+    systemPrompt?: string;
+    contextWindow?: number;
+    maxTokens?: number;
+    thinkingLevel?: ThinkingLevelName;
+    /** LLM Request timeout (ms): from system_config.model.timeoutMs; <=0 disables it. Defaults to 120000. */
+    requestTimeoutMs?: number;
+    /**
+     * tool_call_id uniqueness registry (Session-level). Pass the same instance when rebuilding a new
+     * GenerativeModel on compaction so the uniqueness scope covers the whole Session; defaults to a fresh
+     * one. See llm/tool-call-ids.ts.
+     */
+    toolCallIds?: ToolCallIdAllocator;
+}
+interface GenerativeModelParameters {
+    /** OmniMessage array for the input newly added this turn; implementations must merge it into a single UniMessage (multiple roles not accepted). */
+    newMessages: OmniMessage[];
+    signal?: AbortSignal;
+}
+/**
+ * The terminal state of an LLM request, returned as the **return value** of the `streamGenerate`
+ * async generator (not a yielded message). The status values share the same five-value protocol
+ * as OmniMessage `stop_reason`:
+ *   - `completed`: finished normally (already produced `token_usage`);
+ *   - `timeout`: LLM timed out or lost connection, needs reconnect — retried by `context_engine`
+ *     within the same run;
+ *   - `malformed`: AgentHub response failed JSON parsing, needs reconnect — also retried by
+ *     `context_engine`;
+ *   - `aborted`: user-initiated interruption — stop and hand back to the user;
+ *   - `failed`: other non-retryable errors (auth/params, etc.) — stop and hand back to the user
+ *     (`message` provides the display text).
+ * Docs: /docs/interfaces § "LLMOutcome semantics".
+ */
+interface LLMOutcome {
+    status: StopReason;
+    message?: string;
+}
+/**
+ * A stateful LLM object attached to a Session.
+ * `streamGenerate` yields streaming `partial_*` messages as an async generator, and appends the
+ * corresponding complete `model_msg` once each fragment ends; Token usage is emitted as a
+ * `token_usage` event_msg. **Never throws to `context_engine`**: any interruption/exception is
+ * closed off in well-formed structure and returned normally, and **must** report the terminal
+ * state via `LLMOutcome` — error handling happens entirely inside the LLM interface, and
+ * `context_engine` only decides subsequent actions based on the outcome.
+ * Docs: /docs/interfaces § "LLMInterface".
+ */
+interface LLMInterface {
+    streamGenerate(parameters: GenerativeModelParameters): AsyncGenerator<OmniMessage, LLMOutcome>;
+}
+/**
+ * Handle for a child Agent session: derived by `SubagentRunner.spawn`,
+ * representing a child Session that can run over multiple turns. Deriving (spawn) is separate
+ * from running (run), so the same child Session can accept an additional Prompt and keep running
+ * after a turn ends (a long-running subagent, accessed via `input_subagent`).
+ * Docs: /docs/interfaces § "Subagent interfaces".
+ */
+interface SubagentHandle {
+    /** The child Session's id: the origin hop of messages produced by run; `subagent_id` is derived from its tail for the frontend to correlate. */
+    sessionId: string;
+    /**
+     * Runs one turn of a task on the child Session. Emitted child-session messages **all already
+     * carry the origin marker** (the child Session id); the first message of the first run is the
+     * child Session's `session_meta`, and tool_calls received by the forwarded approval callback
+     * carry origin as well.
+     */
+    run(input: {
+        /** The task Prompt handed to the child Agent. */
+        prompt: string;
+        signal?: AbortSignal;
+        /** The parent Agent's approval callback; forwarded to the child Session to inherit the parent's approval mode. */
+        approve?: ApproveFn;
+    }): AsyncGenerator<OmniMessage>;
+    /** Releases runtime resources held by the child Session (e.g. its managed command sessions). Idempotent. */
+    dispose(): void;
+}
+/**
+ * Child Agent runner: injected into the `run_subagent` tool so it can
+ * derive and run a child Agent without a reverse dependency on Agent/Session, avoiding circular
+ * dependencies. The concrete implementation is provided by the SDK composition layer (where
+ * `createAgent` lives), which internally derives via `createAgent` → `createSession` and hands
+ * back a `SubagentHandle`.
+ * Docs: /docs/interfaces § "Subagent interfaces".
+ */
+interface SubagentRunner {
+    /**
+     * Derives a child Agent and creates a child Session. Precheck errors such as exceeding the
+     * depth limit or a nonexistent target agent are expressed by throwing (collapsed to `failed`
+     * by Environment).
+     */
+    spawn(input: {
+        /** The child Agent's agentId; if omitted, reuses the current Agent (self-invocation). */
+        agentId?: string;
+        /** The Model used by the child Session; if omitted, uses the Project's default Model. */
+        modelId?: string;
+    }): Promise<SubagentHandle>;
+}
+/**
+ * Proxy-reading service for describe_image: injected when the session model doesn't support
+ * images (vision=false) — images are handed to the configured vision model for description and
+ * the tool returns text, avoiding a 400 from feeding images back into a tool_result for a
+ * provider that doesn't support images.
+ * Docs: /docs/interfaces § "VisionDescriberService".
+ */
+interface VisionDescriberService {
+    /** Vision model id; null when the Project has no `vision_model` configured (or it's invalid), in which case the tool ends with a failed explanation. */
+    modelId: string | null;
+    /** Constructs a single-shot LLM for this vision model (no tools, no system prompt); omitted when `modelId` is null. */
+    createLLM?: () => LLMInterface;
+}
+/**
+ * Runtime services Environment injects into individual tools (e.g. `run_subagent` needs `SubagentRunner`); most tools don't use these.
+ * Docs: /docs/interfaces § "ToolExecutionRequest and EnvironmentConfig".
+ */
+interface EnvironmentServices {
+    subagentRunner?: SubagentRunner;
+    /** Injected when the session model doesn't support images: for describe_image's single-shot vision-model proxy reading. */
+    visionDescriber?: VisionDescriberService;
+    /** Registry of long-running command sessions (shared by `exec_command` / `input_command`); constructed and injected internally by Environment. */
+    commandSessions?: CommandSessionManager;
+    /** Registry of background subagent sessions (shared by `run_subagent` / `input_subagent`); constructed and injected internally by Environment. */
+    subagentSessions?: SubagentSessionManager;
+}
+/** Docs: /docs/interfaces § "ToolExecutionRequest and EnvironmentConfig". */
+interface EnvironmentConfig {
+    workspaceDir: string;
+    toolConfig: ToolConfig;
+    /** Runtime services (optional); Environment forwards these to each tool factory to use as needed. */
+    services?: EnvironmentServices;
+    /**
+     * Agent vault environment variables (key-value pairs, taken from the Agent's
+     * `agent_state/.vault.toml`): injected into the exec_command / input_command subprocess
+     * environment; hardened entries cannot be overridden.
+     */
+    vault?: Record<string, string>;
+}
+/**
+ * An approved tool-call execution request.
+ * Docs: /docs/interfaces § "ToolExecutionRequest and EnvironmentConfig".
+ */
+interface ToolExecutionRequest {
+    /** The OmniMessage whose payload.type === "tool_call". */
+    toolCall: OmniMessage<ToolCallPayload>;
+    signal?: AbortSignal;
+    /** The parent Agent's approval callback; forwarded to tools that need to derive a child Session (run_subagent), implementing approval inheritance. */
+    approve?: ApproveFn;
+}
+/**
+ * Environment interface: executes approved tool calls within the Workspace.
+ * `executeTool` yields `partial_tool_call_output` as an async generator and ends with exactly one
+ * complete `tool_call_output`; nested session messages carrying an origin marker (e.g. forwarded
+ * by run_subagent) pass through unchanged.
+ *
+ * **Rendering** of tool calls is not this interface's concern (nor core's): streaming rendering is
+ * handled by the CLI / Web frontend itself.
+ * Docs: /docs/interfaces § "EnvironmentInterface".
+ */
+interface EnvironmentInterface {
+    listTools(): Promise<ToolDefinition[]>;
+    executeTool(request: ToolExecutionRequest): AsyncGenerator<OmniMessage>;
+    /** Looks up a tool's permission level (for frontend permission-mode decisions); returns undefined for unknown tools. */
+    toolPermission(name: string): ToolPermission | undefined;
+    /** Releases runtime resources held by the environment (e.g. managed long-running command sessions); called by the host when the Session ends. Optional, idempotent. */
+    dispose?(): void;
+}
+
+export { type ApproveFn as A, CommandSessionManager as C, type EnvironmentInterface as E, type GenerativeModelConfig as G, type LLMInterface as L, type MCPServerConfig as M, type ProcessExit as P, type SpawnOptions as S, type ToolDefinitionConfig as T, type VisionDescriberService as V, type ThinkingLevelName as a, type ToolConfig as b, ToolCallIdAllocator as c, type GenerativeModelParameters as d, type LLMOutcome as e, type EnvironmentConfig as f, type ToolPermission as g, type ToolExecutionRequest as h, type EnvironmentServices as i, ManagedSession as j, ManagedSubagentSession as k, type SubagentHandle as l, type SubagentRunner as m, SubagentSessionManager as n, stripToolCallIdSuffix as s };

package/dist/interfaces.d.ts

@@ -0,0 +1,2 @@
+export { T as ToolDefinition } from './types-D6FERSdT.js';
+export { A as ApproveFn, f as EnvironmentConfig, E as EnvironmentInterface, i as EnvironmentServices, G as GenerativeModelConfig, d as GenerativeModelParameters, L as LLMInterface, e as LLMOutcome, M as MCPServerConfig, l as SubagentHandle, m as SubagentRunner, a as ThinkingLevelName, b as ToolConfig, T as ToolDefinitionConfig, h as ToolExecutionRequest, g as ToolPermission, V as VisionDescriberService } from './interfaces-CMSN7-pO.js';

package/dist/interfaces.js

@@ -0,0 +1,2 @@
+import "./chunk-HRIXWKKE.js";
+//# sourceMappingURL=interfaces.js.map

package/dist/interfaces.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}