zidane 7.2.5 → 8.0.4

package/dist/types-IqegbJEE.d.ts

@@ -0,0 +1,624 @@
+import { My as PromptPart, Vy as SessionContentBlock, Xi as AgentOptions, Yi as Agent, Zb as Session, ab as ToolResultContent, bb as ToolDef, ny as AgentBehavior, s_ as Provider, t as Preset, tx as SessionStore, xy as McpServerConfig } from "./index-BGe1fQT7.js";
+import { h as ExecutionContext } from "./isolation-D9L650W5.js";
+//#region src/acp/client-declared-tools.d.ts
+/** JSON-RPC method the agent sends to the client to run a client-declared tool. */
+declare const CLIENT_TOOL_CALL_METHOD = "_zidane/tool_call";
+/** Notification the agent sends when it abandons a pending {@link CLIENT_TOOL_CALL_METHOD}. */
+declare const CLIENT_TOOL_CANCEL_METHOD = "_zidane/tool_call_cancel";
+/**
+ * A tool the ACP client declares in `session/new` / `session/load` /
+ * `session/resume` under `_meta.zidane.clientTools`. The agent sees it like
+ * any other tool; execution round-trips to the client over
+ * {@link CLIENT_TOOL_CALL_METHOD}.
+ */
+interface AcpClientToolSpec {
+  name: string;
+  description: string;
+  inputSchema: Record<string, unknown>;
+  /** Mutating tools go through permission requests and are hidden in Plan mode. */
+  mutating: boolean;
+}
+interface ClientToolCallResponse {
+  content?: unknown;
+  isError?: unknown;
+}
+/**
+ * Validate `_meta.zidane.clientTools`. Returns `undefined` when the key is
+ * absent (so resume can keep the existing set) and throws on malformed specs.
+ */
+declare function parseClientToolSpecs(meta: Record<string, unknown> | null | undefined): AcpClientToolSpec[] | undefined;
+declare function createClientDeclaredTools(specs: readonly AcpClientToolSpec[], options: {
+  client: AcpPeer;
+  sessionId: string;
+}): Record<string, ToolDef>;
+//#endregion
+//#region src/acp/types.d.ts
+declare const ACP_PROTOCOL_VERSION = 1;
+type JsonRpcId = string | number | null;
+interface JsonRpcRequest {
+  jsonrpc: '2.0';
+  id: JsonRpcId;
+  method: string;
+  params?: unknown;
+}
+interface JsonRpcNotification {
+  jsonrpc: '2.0';
+  method: string;
+  params?: unknown;
+}
+interface JsonRpcSuccess {
+  jsonrpc: '2.0';
+  id: JsonRpcId;
+  result: unknown;
+}
+interface JsonRpcFailure {
+  jsonrpc: '2.0';
+  id: JsonRpcId;
+  error: JsonRpcError;
+}
+type JsonRpcResponse = JsonRpcSuccess | JsonRpcFailure;
+type JsonRpcMessage = JsonRpcRequest | JsonRpcNotification | JsonRpcResponse;
+interface JsonRpcError {
+  code: number;
+  message: string;
+  data?: unknown;
+}
+declare enum AcpErrorCode {
+  ParseError = -32700,
+  InvalidRequest = -32600,
+  MethodNotFound = -32601,
+  InvalidParams = -32602,
+  InternalError = -32603,
+  AuthenticationRequired = -32000,
+  ResourceNotFound = -32002
+}
+interface AcpPeer {
+  sendRequest: (method: string, params?: unknown) => Promise<unknown>;
+  sendNotification: (method: string, params?: unknown) => void | Promise<void>;
+}
+/**
+ * ACP `Implementation` metadata. The spec requires `name` + `version`;
+ * `title` is an optional UI label. Incoming `clientInfo` is treated loosely
+ * (see {@link InitializeRequest}) since we never reflect it back on the wire.
+ */
+interface AcpImplementationInfo {
+  name: string;
+  version: string;
+  title?: string | null;
+  _meta?: Record<string, unknown> | null;
+}
+interface AcpClientCapabilities {
+  fs?: {
+    readTextFile?: boolean;
+    writeTextFile?: boolean;
+  };
+  terminal?: boolean;
+  _meta?: Record<string, unknown> | null;
+}
+interface InitializeRequest {
+  protocolVersion: number;
+  clientCapabilities?: AcpClientCapabilities;
+  clientInfo?: Partial<AcpImplementationInfo>;
+  _meta?: Record<string, unknown> | null;
+}
+interface AgentCapabilities {
+  loadSession?: boolean;
+  promptCapabilities?: PromptCapabilities;
+  mcpCapabilities?: McpCapabilities;
+  sessionCapabilities?: SessionCapabilities;
+  auth?: AgentAuthCapabilities;
+  _meta?: Record<string, unknown> | null;
+}
+interface PromptCapabilities {
+  image?: boolean;
+  audio?: boolean;
+  embeddedContext?: boolean;
+  _meta?: Record<string, unknown> | null;
+}
+interface McpCapabilities {
+  http?: boolean;
+  sse?: boolean;
+  _meta?: Record<string, unknown> | null;
+}
+interface AgentAuthCapabilities {
+  logout?: Record<string, unknown> | null;
+  _meta?: Record<string, unknown> | null;
+}
+interface SessionCapabilities {
+  list?: Record<string, unknown> | null;
+  delete?: Record<string, unknown> | null;
+  additionalDirectories?: Record<string, unknown> | null;
+  resume?: Record<string, unknown> | null;
+  close?: Record<string, unknown> | null;
+  _meta?: Record<string, unknown> | null;
+}
+interface InitializeResponse {
+  protocolVersion: number;
+  agentCapabilities: AgentCapabilities;
+  agentInfo?: AcpImplementationInfo;
+  authMethods: AuthMethod[];
+  _meta?: Record<string, unknown> | null;
+}
+interface AuthMethod {
+  id: string;
+  name: string;
+  description?: string | null;
+  _meta?: Record<string, unknown> | null;
+}
+interface AuthenticateRequest {
+  methodId: string;
+  _meta?: Record<string, unknown> | null;
+}
+interface NewSessionRequest {
+  cwd: string;
+  additionalDirectories?: string[];
+  mcpServers: AcpMcpServer[];
+  _meta?: Record<string, unknown> | null;
+}
+interface LoadSessionRequest extends NewSessionRequest {
+  sessionId: string;
+}
+interface ResumeSessionRequest {
+  sessionId: string;
+  cwd: string;
+  additionalDirectories?: string[];
+  mcpServers?: AcpMcpServer[];
+  _meta?: Record<string, unknown> | null;
+}
+interface CloseSessionRequest {
+  sessionId: string;
+  _meta?: Record<string, unknown> | null;
+}
+interface DeleteSessionRequest {
+  sessionId: string;
+  _meta?: Record<string, unknown> | null;
+}
+interface ListSessionsRequest {
+  cwd?: string | null;
+  cursor?: string | null;
+  _meta?: Record<string, unknown> | null;
+}
+interface SessionInfo {
+  sessionId: string;
+  cwd: string;
+  additionalDirectories?: string[];
+  title?: string | null;
+  updatedAt?: string | null;
+  _meta?: Record<string, unknown> | null;
+}
+interface ListSessionsResponse {
+  sessions: SessionInfo[];
+  nextCursor?: string | null;
+  _meta?: Record<string, unknown> | null;
+}
+interface NewSessionResponse {
+  sessionId: string;
+  modes?: SessionModeState | null;
+  configOptions?: SessionConfigOption[] | null;
+  _meta?: Record<string, unknown> | null;
+}
+/**
+ * `session/load` and `session/resume` responses do NOT echo `sessionId` and
+ * carry no inline message history. Conversation history is replayed via
+ * `session/update` notifications before the response is returned.
+ */
+interface LoadSessionResponse {
+  modes?: SessionModeState | null;
+  configOptions?: SessionConfigOption[] | null;
+  _meta?: Record<string, unknown> | null;
+}
+type ResumeSessionResponse = LoadSessionResponse;
+interface PromptRequest {
+  sessionId: string;
+  prompt: ContentBlock[];
+  _meta?: Record<string, unknown> | null;
+}
+interface PromptResponse {
+  stopReason: StopReason;
+  _meta?: Record<string, unknown> | null;
+}
+type StopReason = 'end_turn' | 'max_tokens' | 'max_turn_requests' | 'refusal' | 'cancelled';
+interface CancelNotification {
+  sessionId: string;
+  _meta?: Record<string, unknown> | null;
+}
+interface SetSessionModeRequest {
+  sessionId: string;
+  modeId: string;
+  _meta?: Record<string, unknown> | null;
+}
+interface SetSessionConfigOptionRequest {
+  sessionId: string;
+  configId: string;
+  value: string;
+  _meta?: Record<string, unknown> | null;
+}
+interface SetSessionConfigOptionResponse {
+  configOptions: SessionConfigOption[];
+  _meta?: Record<string, unknown> | null;
+}
+interface SessionMode {
+  id: string;
+  name: string;
+  description?: string | null;
+  _meta?: Record<string, unknown> | null;
+}
+interface SessionModeState {
+  currentModeId: string;
+  availableModes: SessionMode[];
+  _meta?: Record<string, unknown> | null;
+}
+type AcpMcpServer = {
+  type?: 'stdio';
+  name: string;
+  command: string;
+  args: string[];
+  env: EnvVariable[];
+  _meta?: Record<string, unknown> | null;
+} | {
+  type: 'http' | 'sse';
+  name: string;
+  url: string;
+  headers: HttpHeader[];
+  _meta?: Record<string, unknown> | null;
+};
+interface EnvVariable {
+  name: string;
+  value: string;
+  _meta?: Record<string, unknown> | null;
+}
+interface HttpHeader {
+  name: string;
+  value: string;
+  _meta?: Record<string, unknown> | null;
+}
+type ContentBlock = TextContent | ImageContent | AudioContent | ResourceLink | EmbeddedResource;
+type Role = 'user' | 'assistant';
+interface ContentAnnotations {
+  audience?: Role[] | null;
+  lastModified?: string | null;
+  priority?: number | null;
+  _meta?: Record<string, unknown> | null;
+}
+interface TextContent {
+  type: 'text';
+  text: string;
+  annotations?: ContentAnnotations | null;
+  _meta?: Record<string, unknown> | null;
+}
+interface ImageContent {
+  type: 'image';
+  data: string;
+  mimeType: string;
+  uri?: string | null;
+  annotations?: ContentAnnotations | null;
+  _meta?: Record<string, unknown> | null;
+}
+interface AudioContent {
+  type: 'audio';
+  data: string;
+  mimeType: string;
+  annotations?: ContentAnnotations | null;
+  _meta?: Record<string, unknown> | null;
+}
+interface ResourceLink {
+  type: 'resource_link';
+  uri: string;
+  name: string;
+  title?: string | null;
+  description?: string | null;
+  mimeType?: string | null;
+  size?: number | null;
+  annotations?: ContentAnnotations | null;
+  _meta?: Record<string, unknown> | null;
+}
+interface TextResourceContents {
+  uri: string;
+  text: string;
+  mimeType?: string | null;
+  _meta?: Record<string, unknown> | null;
+}
+interface BlobResourceContents {
+  uri: string;
+  blob: string;
+  mimeType?: string | null;
+  _meta?: Record<string, unknown> | null;
+}
+type EmbeddedResourceResource = TextResourceContents | BlobResourceContents;
+interface EmbeddedResource {
+  type: 'resource';
+  resource: EmbeddedResourceResource;
+  annotations?: ContentAnnotations | null;
+  _meta?: Record<string, unknown> | null;
+}
+interface ContentChunk {
+  content: ContentBlock;
+  messageId?: string | null;
+  _meta?: Record<string, unknown> | null;
+}
+type ToolKind = 'read' | 'edit' | 'delete' | 'move' | 'search' | 'execute' | 'think' | 'fetch' | 'switch_mode' | 'other';
+type ToolCallStatus = 'pending' | 'in_progress' | 'completed' | 'failed';
+type ToolCallContent = {
+  type: 'content';
+  content: ContentBlock;
+  _meta?: Record<string, unknown> | null;
+} | {
+  type: 'diff';
+  path: string;
+  oldText?: string | null;
+  newText: string;
+  _meta?: Record<string, unknown> | null;
+} | {
+  type: 'terminal';
+  terminalId: string;
+  _meta?: Record<string, unknown> | null;
+};
+interface ToolCallLocation {
+  path: string;
+  line?: number | null;
+  _meta?: Record<string, unknown> | null;
+}
+interface ToolCallUpdate {
+  toolCallId: string;
+  title?: string | null;
+  kind?: ToolKind | null;
+  status?: ToolCallStatus | null;
+  content?: ToolCallContent[] | null;
+  locations?: ToolCallLocation[] | null;
+  rawInput?: unknown;
+  rawOutput?: unknown;
+  _meta?: Record<string, unknown> | null;
+}
+type SessionUpdate = ({
+  sessionUpdate: 'user_message_chunk';
+} & ContentChunk) | ({
+  sessionUpdate: 'agent_message_chunk';
+} & ContentChunk) | ({
+  sessionUpdate: 'agent_thought_chunk';
+} & ContentChunk) | ({
+  sessionUpdate: 'tool_call';
+} & ToolCallUpdate) | ({
+  sessionUpdate: 'tool_call_update';
+} & ToolCallUpdate) | {
+  sessionUpdate: 'plan';
+  entries: PlanEntry[];
+  _meta?: Record<string, unknown> | null;
+} | {
+  sessionUpdate: 'available_commands_update';
+  availableCommands: AvailableCommand[];
+  _meta?: Record<string, unknown> | null;
+} | {
+  sessionUpdate: 'current_mode_update';
+  currentModeId: string;
+  _meta?: Record<string, unknown> | null;
+} | {
+  sessionUpdate: 'config_option_update';
+  configOptions: SessionConfigOption[];
+  _meta?: Record<string, unknown> | null;
+} | {
+  sessionUpdate: 'session_info_update';
+  title?: string | null;
+  updatedAt?: string | null;
+  _meta?: Record<string, unknown> | null;
+} | {
+  sessionUpdate: 'usage_update';
+  used: number;
+  size: number;
+  cost?: Cost | null;
+  _meta?: Record<string, unknown> | null;
+};
+interface SessionNotification {
+  sessionId: string;
+  update: SessionUpdate;
+  _meta?: Record<string, unknown> | null;
+}
+interface PlanEntry {
+  content: string;
+  priority: 'high' | 'medium' | 'low';
+  status: 'pending' | 'in_progress' | 'completed';
+  _meta?: Record<string, unknown> | null;
+}
+interface AvailableCommand {
+  name: string;
+  description: string;
+  input?: AvailableCommandInput | null;
+  _meta?: Record<string, unknown> | null;
+}
+interface AvailableCommandInput {
+  hint: string;
+  _meta?: Record<string, unknown> | null;
+}
+interface SessionConfigSelectOption {
+  value: string;
+  name: string;
+  description?: string | null;
+  _meta?: Record<string, unknown> | null;
+}
+interface SessionConfigSelectGroup {
+  group: string;
+  name: string;
+  options: SessionConfigSelectOption[];
+  _meta?: Record<string, unknown> | null;
+}
+type SessionConfigSelectOptions = SessionConfigSelectOption[] | SessionConfigSelectGroup[];
+type SessionConfigOptionCategory = 'mode' | 'model' | 'thought_level' | (string & {});
+/**
+ * A session configuration option. ACP v1 currently defines a single
+ * `select` (dropdown) variant; `id` + `name` + `type` are required.
+ */
+interface SessionConfigOption {
+  id: string;
+  name: string;
+  type: 'select';
+  currentValue: string;
+  options: SessionConfigSelectOptions;
+  description?: string | null;
+  category?: SessionConfigOptionCategory | null;
+  _meta?: Record<string, unknown> | null;
+}
+interface Cost {
+  amount: number;
+  currency: string;
+  _meta?: Record<string, unknown> | null;
+}
+interface PermissionOption {
+  optionId: string;
+  name: string;
+  kind: 'allow_once' | 'allow_always' | 'reject_once' | 'reject_always';
+  _meta?: Record<string, unknown> | null;
+}
+type RequestPermissionOutcome = {
+  outcome: 'cancelled';
+} | {
+  outcome: 'selected';
+  optionId: string;
+  _meta?: Record<string, unknown> | null;
+};
+interface RequestPermissionRequest {
+  sessionId: string;
+  toolCall: ToolCallUpdate;
+  options: PermissionOption[];
+  _meta?: Record<string, unknown> | null;
+}
+interface ReadTextFileRequest {
+  sessionId: string;
+  path: string;
+  line?: number | null;
+  limit?: number | null;
+  _meta?: Record<string, unknown> | null;
+}
+interface WriteTextFileRequest {
+  sessionId: string;
+  path: string;
+  content: string;
+  _meta?: Record<string, unknown> | null;
+}
+interface CreateTerminalRequest {
+  sessionId: string;
+  command: string;
+  args?: string[];
+  env?: EnvVariable[];
+  cwd?: string | null;
+  outputByteLimit?: number | null;
+  _meta?: Record<string, unknown> | null;
+}
+interface TerminalExitStatus {
+  exitCode?: number | null;
+  signal?: string | null;
+  _meta?: Record<string, unknown> | null;
+}
+interface TerminalOutputResponse {
+  output: string;
+  truncated: boolean;
+  exitStatus?: TerminalExitStatus | null;
+  _meta?: Record<string, unknown> | null;
+}
+interface AcpSessionRuntime {
+  sessionId: string;
+  cwd: string;
+  additionalDirectories: string[];
+  mcpServers: McpServerConfig[];
+  /** Tools declared by the client under `_meta.zidane.clientTools`. */
+  clientTools: AcpClientToolSpec[];
+  session: Session;
+  execution: ExecutionContext;
+  agent: Agent;
+  /**
+   * Provider bound to {@link agent}. In model-registry mode this is a router
+   * whose `meta` reflects the currently selected model's underlying provider,
+   * so `resolveContextWindow` stays correct across `session/set_config_option`.
+   */
+  provider: Provider;
+  tools?: Record<string, ToolDef>;
+  modeId: string;
+  configOptions: SessionConfigOption[];
+  config: Map<string, unknown>;
+  /** Model id passed to `agent.run({ model })`; the selected choice's `model`. */
+  runModel?: string;
+  /** Swap the router's underlying provider on a model switch (registry mode). */
+  setProviderDelegate?: (provider: Provider) => void;
+  abortController?: AbortController;
+  inFlight?: Promise<PromptResponse>;
+}
+interface AcpPermissionPolicy {
+  enabled?: boolean;
+  toolMatcher?: (toolName: string, input: Record<string, unknown>) => boolean;
+  options?: PermissionOption[];
+}
+/**
+ * A user-selectable model exposed to ACP clients as a `category: 'model'`
+ * session config option. Each choice carries its OWN provider so switching a
+ * model can switch provider + credentials. `provider` may be a factory so the
+ * credentials for a model are only resolved when that model is first selected.
+ */
+interface AcpModelChoice {
+  /** Stable id used as the config option value (also the dropdown key). */
+  id: string;
+  /** Human label shown in the client dropdown. Defaults to `model`. */
+  name?: string;
+  /** Model id passed to `agent.run({ model })` for this choice. */
+  model: string;
+  /** Whether this model supports a thinking/effort selector. */
+  reasoning?: boolean;
+  /** Model-specific boolean options exposed as ACP select controls. */
+  options?: AcpModelOption[];
+  /** Provider serving this model; a factory is built lazily on first use. */
+  provider: Provider | (() => Provider);
+}
+interface AcpModelOption {
+  id: string;
+  label: string;
+  description?: string;
+}
+interface AcpServerOptions {
+  /**
+   * Single provider used for every run. Required UNLESS {@link models} is
+   * supplied (the registry then owns provider resolution per selected model).
+   */
+  provider?: Provider | (() => Provider);
+  model?: string;
+  /**
+   * Selectable models advertised to the client as a `category: 'model'` config
+   * option. When present, the client (e.g. Zed) can switch models via
+   * `session/set_config_option`, and each model resolves its own provider +
+   * credentials. Supersedes {@link provider} for run routing.
+   */
+  models?: AcpModelChoice[];
+  /** Initially-selected {@link AcpModelChoice.id}. Defaults to the first entry. */
+  defaultModelId?: string;
+  preset?: Preset;
+  tools?: Record<string, ToolDef>;
+  system?: string;
+  behavior?: AgentBehavior;
+  store?: SessionStore;
+  execution?: ExecutionContext | ((request: NewSessionRequest | LoadSessionRequest | ResumeSessionRequest) => ExecutionContext);
+  agentInfo?: AcpImplementationInfo;
+  authMethods?: AuthMethod[];
+  authenticate?: (request: AuthenticateRequest) => Promise<unknown> | unknown;
+  logout?: () => Promise<unknown> | unknown;
+  modes?: SessionMode[];
+  defaultModeId?: string;
+  configOptions?: SessionConfigOption[];
+  /** Slash commands advertised via `available_commands_update` on session start. */
+  commands?: AvailableCommand[];
+  /**
+   * Total context-window size (tokens) reported in `usage_update.size`. ACP
+   * requires `size` on every usage update, so when neither this nor the
+   * provider's `meta.contextWindow` is known, usage updates are suppressed
+   * rather than sent with a fabricated window.
+   */
+  contextWindow?: number;
+  permission?: AcpPermissionPolicy;
+  useClientFileSystem?: boolean;
+  useClientTerminal?: boolean;
+  agentOptions?: Partial<Omit<AgentOptions, 'provider' | 'execution' | 'session'>>;
+}
+interface AcpPromptMapping {
+  prompt: PromptPart[];
+  warnings: string[];
+}
+type AcpContentMapper = (content: string | ToolResultContent[]) => ToolCallContent[];
+type AcpSessionContentMapper = (blocks: SessionContentBlock[]) => ContentBlock[];
+//#endregion
+export { PermissionOption as $, DeleteSessionRequest as A, ToolCallContent as At, JsonRpcId as B, createClientDeclaredTools as Bt, CancelNotification as C, SetSessionConfigOptionResponse as Ct, ContentChunk as D, TerminalOutputResponse as Dt, ContentBlock as E, TerminalExitStatus as Et, ImageContent as F, WriteTextFileRequest as Ft, JsonRpcSuccess as G, JsonRpcNotification as H, InitializeRequest as I, AcpClientToolSpec as It, LoadSessionRequest as J, ListSessionsRequest as K, InitializeResponse as L, CLIENT_TOOL_CALL_METHOD as Lt, EmbeddedResourceResource as M, ToolCallStatus as Mt, EnvVariable as N, ToolCallUpdate as Nt, Cost as O, TextContent as Ot, HttpHeader as P, ToolKind as Pt, NewSessionResponse as Q, JsonRpcError as R, CLIENT_TOOL_CANCEL_METHOD as Rt, BlobResourceContents as S, SetSessionConfigOptionRequest as St, ContentAnnotations as T, StopReason as Tt, JsonRpcRequest as U, JsonRpcMessage as V, parseClientToolSpecs as Vt, JsonRpcResponse as W, McpCapabilities as X, LoadSessionResponse as Y, NewSessionRequest as Z, AudioContent as _, SessionInfo as _t, AcpImplementationInfo as a, RequestPermissionOutcome as at, AvailableCommand as b, SessionNotification as bt, AcpModelOption as c, ResumeSessionRequest as ct, AcpPromptMapping as d, SessionCapabilities as dt, PlanEntry as et, AcpServerOptions as f, SessionConfigOption as ft, AgentCapabilities as g, SessionConfigSelectOptions as gt, AgentAuthCapabilities as h, SessionConfigSelectOption as ht, AcpErrorCode as i, ReadTextFileRequest as it, EmbeddedResource as j, ToolCallLocation as jt, CreateTerminalRequest as k, TextResourceContents as kt, AcpPeer as l, ResumeSessionResponse as lt, AcpSessionRuntime as m, SessionConfigSelectGroup as mt, AcpClientCapabilities as n, PromptRequest as nt, AcpMcpServer as o, RequestPermissionRequest as ot, AcpSessionContentMapper as p, SessionConfigOptionCategory as pt, ListSessionsResponse as q, AcpContentMapper as r, PromptResponse as rt, AcpModelChoice as s, ResourceLink as st, ACP_PROTOCOL_VERSION as t, PromptCapabilities as tt, AcpPermissionPolicy as u, Role as ut, AuthMethod as v, SessionMode as vt, CloseSessionRequest as w, SetSessionModeRequest as wt, AvailableCommandInput as x, SessionUpdate as xt, AuthenticateRequest as y, SessionModeState as yt, JsonRpcFailure as z, ClientToolCallResponse as zt };
+//# sourceMappingURL=types-IqegbJEE.d.ts.map

package/dist/types-IqegbJEE.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-IqegbJEE.d.ts","names":["_$__client_declared_tools0.AcpClientToolSpec","_$___agent0.Agent"],"sources":["../src/acp/client-declared-tools.ts","../src/acp/types.ts"],"mappings":"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"}

package/dist/types.d.ts

@@ -1,6 +1,6 @@
-import { $_ as ToolHookContext, A_ as PromptPart, B_ as SessionEndStatus, Br as InteractionToolOptions, Bv as SkillConfig, C as SuccessfulMutationOutcome, Cv as ReadStateMap, D_ as PromptAudioPart, Dh as OpenRouterParams, E_ as ProgressNudgeMessage, F_ as ResolveContentRef, Fv as ToolStateView, Gv as CreateSessionOptions, H_ as SessionMessage, Hv as SkillResource, I_ as ResolveContentRefBlock, Ji as AgentHookMap, Jv as SessionData, L_ as RetryConfig, M_ as PromptVideoPart, Mv as ToolStateController, N_ as RepeatGuardConfig, Nv as ToolStateOp, O_ as PromptDocumentPart, P_ as RepeatGuardToolMatcher, Pv as ToolStateStore, Qy as McpConnection, R_ as RunHookMap, S as MutationValidationResult, Sc as SpawnToolState, Sv as ReadStateEntry, T_ as ProgressNudgeKind, U_ as SessionTurn, V_ as SessionHookContext, W_ as SpawnHookContext, Wv as SkillsConfig, Xi as AgentOptions, Xv as SessionRun, Yi as AgentHooks, Z_ as ThinkingLevel, Zh as OpenAIParams, Zi as AgentToolState, Zv as SessionStore, _ as statsByModel, _v as ToolDescriptionOverride, a_ as AgentStats, av as ToolResultImageContent, b as MutationValidationHooksOptions, b_ as McpToolHookContext, bv as ToolMap, ch as ProviderCapabilities, cv as ToolResultTextContent, dh as StreamOptions, dv as TurnUsage, ev as ToolOutcome, fv as toolOutputBudgetByteLength, gc as ChildAgent, gh as TurnResult, gv as ToolDef, h as flattenTurns, hh as ToolSpec, hv as ToolContext, i_ as AgentRunOptions, iv as ToolResultDocumentRefContent, j_ as PromptTextPart, jv as StagedToolState, k_ as PromptImagePart, l_ as ChildRunStats, lg as CerebrasParams, lv as ToolResultVideoContent, m_ as DEFAULT_AGENT_CLOCK, mh as ToolResult, mv as toolResultToText, n_ as AgentBehavior, nv as ToolResultContent, ov as ToolResultImageRefContent, p as ModelUsage, ph as ToolCall, pv as toolOutputByteLength, q_ as StreamHookContext, qi as Agent, qv as Session, r_ as AgentClock, rv as ToolResultDocumentContent, sh as Provider, sv as ToolResultMetadata, sy as RemoteStoreOptions, t as Preset, tv as ToolResultAudioContent, uh as StreamCallbacks, uv as TurnFinishReason, v as MutationValidationBatch, vg as AnthropicParams, vr as ValidationResult, vv as ToolDescriptionTarget, w_ as OAuthRefreshHookContext, x as MutationValidationMutation, xc as SpawnToolOptions, y as MutationValidationFailure, y_ as McpServerConfig, yv as ToolDescriptions, z_ as SessionContentBlock } from "./index-BgN1T3lk.js";
+import { Ay as PromptDocumentPart, Bg as AgentHookMap, By as RunHookMap, C as SuccessfulMutationOutcome, Cb as ToolDescriptions, D_ as OpenRouterParams, Db as ReadStateMap, Dy as ProgressNudgeKind, Eb as ReadStateEntry, Ey as OAuthRefreshHookContext, Fb as StagedToolState, Fy as RepeatGuardConfig, Gy as SessionTurn, Hy as SessionEndStatus, Ib as ToolStateController, Iy as RepeatGuardToolMatcher, Jb as SkillsConfig, Kb as SkillResource, Ky as SpawnHookContext, Lb as ToolStateOp, Ly as ResolveContentRef, My as PromptPart, Ny as PromptTextPart, Oy as ProgressNudgeMessage, Py as PromptVideoPart, Qb as SessionData, Rb as ToolStateStore, Rr as InteractionToolOptions, Ry as ResolveContentRefBlock, S as MutationValidationResult, Sb as ToolDescriptionTarget, Sy as McpToolHookContext, Uy as SessionHookContext, Vg as AgentHooks, Vy as SessionContentBlock, Wb as SkillConfig, Wy as SessionMessage, Xi as AgentOptions, Xy as StreamHookContext, Yb as CreateSessionOptions, Yi as Agent, Z_ as OpenAIParams, Zb as Session, Zi as AgentToolState, _ as statsByModel, _b as toolOutputByteLength, ab as ToolResultContent, ay as AgentStats, b as MutationValidationHooksOptions, bb as ToolDef, c_ as ProviderCapabilities, cb as ToolResultImageContent, cl as SpawnToolOptions, d_ as StreamOptions, db as ToolResultTextContent, dx as RemoteStoreOptions, eb as ThinkingLevel, ex as SessionRun, fb as ToolResultVideoContent, g_ as TurnResult, gb as toolOutputBudgetByteLength, gy as DEFAULT_AGENT_CLOCK, h as flattenTurns, h_ as ToolSpec, ib as ToolResultAudioContent, iy as AgentRunOptions, jy as PromptImagePart, kv as AnthropicParams, ky as PromptAudioPart, lb as ToolResultImageRefContent, ll as SpawnToolState, lv as CerebrasParams, ly as ChildRunStats, m_ as ToolResult, mb as TurnUsage, nS as McpConnection, nb as ToolHookContext, ny as AgentBehavior, ob as ToolResultDocumentContent, p as ModelUsage, p_ as ToolCall, pb as TurnFinishReason, rb as ToolOutcome, rl as ChildAgent, ry as AgentClock, s_ as Provider, sb as ToolResultDocumentRefContent, t as Preset, tx as SessionStore, u_ as StreamCallbacks, ub as ToolResultMetadata, v as MutationValidationBatch, vb as toolResultToText, wb as ToolMap, x as MutationValidationMutation, xb as ToolDescriptionOverride, xy as McpServerConfig, y as MutationValidationFailure, yb as ToolContext, yr as ValidationResult, zb as ToolStateView, zy as RetryConfig } from "./index-BGe1fQT7.js";
 import { d as ClassifiedErrorKind, i as AgentContextExceededError, l as CONTEXT_EXCEEDED_MESSAGE_PATTERNS, n as AgentAbortedError, o as AgentProviderError, p as matchesContextExceeded, r as AgentBudgetExceededError, s as AgentToolNotAllowedError, u as ClassifiedError } from "./timeout-DEaqslLO.js";
-import { C as TaskHandle, S as TaskExitInfo, c as ContextCapabilities, d as ContextType, f as DetachedTasksCapability, h as ExecutionHandle, l as ContextHardening, m as ExecutionContext, p as ExecResult, s as BackgroundTaskStatus, w as TaskStallInfo, x as TaskEntry, y as SpawnConfig } from "./isolation-Kfoof0MM.js";
-import { t as SandboxProvider } from "./sandbox-BH0WQkXn.js";
-import { t as ToolPrompts } from "./prompts-Pqc3JdW_.js";
+import { C as TaskExitInfo, S as TaskEntry, T as TaskStallInfo, b as SpawnConfig, f as ContextType, g as ExecutionHandle, h as ExecutionContext, l as ContextCapabilities, m as ExecResult, p as DetachedTasksCapability, s as BackgroundTaskStatus, u as ContextHardening, w as TaskHandle } from "./isolation-D9L650W5.js";
+import { t as SandboxProvider } from "./sandbox-C5dR5DwQ.js";
+import { t as ToolPrompts } from "./prompts-DYcvqShf.js";
 export { type Agent, AgentAbortedError, type AgentBehavior, AgentBudgetExceededError, type AgentClock, AgentContextExceededError, type AgentHookMap, type AgentHooks, type AgentOptions, AgentProviderError, type AgentRunOptions, type AgentStats, AgentToolNotAllowedError, type AgentToolState, type AnthropicParams, type BackgroundTaskStatus, CONTEXT_EXCEEDED_MESSAGE_PATTERNS, type CerebrasParams, type ChildAgent, type ChildRunStats, type ClassifiedError, type ClassifiedErrorKind, type ContextCapabilities, type ContextHardening, type ContextType, type CreateSessionOptions, DEFAULT_AGENT_CLOCK, type DetachedTasksCapability, type ExecResult, type ExecutionContext, type ExecutionHandle, type InteractionToolOptions, type McpConnection, type McpServerConfig, type McpToolHookContext, type ModelUsage, type MutationValidationBatch, type MutationValidationFailure, type MutationValidationHooksOptions, type MutationValidationMutation, type MutationValidationResult, type OAuthRefreshHookContext, type OpenAIParams, type OpenRouterParams, type Preset, type ProgressNudgeKind, type ProgressNudgeMessage, type PromptAudioPart, type PromptDocumentPart, type PromptImagePart, type PromptPart, type PromptTextPart, type PromptVideoPart, type Provider, type ProviderCapabilities, type ReadStateEntry, type ReadStateMap, type RemoteStoreOptions, type RepeatGuardConfig, type RepeatGuardToolMatcher, type ResolveContentRef, type ResolveContentRefBlock, type RetryConfig, type RunHookMap, type SandboxProvider, type Session, type SessionContentBlock, type SessionData, type SessionEndStatus, type SessionHookContext, type SessionMessage, type SessionRun, type SessionStore, type SessionTurn, type SkillConfig, type SkillResource, type SkillsConfig, type SpawnConfig, type SpawnHookContext, type SpawnToolOptions, type SpawnToolState, type StagedToolState, type StreamCallbacks, type StreamHookContext, type StreamOptions, type SuccessfulMutationOutcome, type TaskEntry, type TaskExitInfo, type TaskHandle, type TaskStallInfo, type ThinkingLevel, type ToolCall, type ToolContext, type ToolDef, type ToolDescriptionOverride, type ToolDescriptionTarget, type ToolDescriptions, type ToolHookContext, type ToolMap, type ToolOutcome, type ToolPrompts, type ToolResult, type ToolResultAudioContent, type ToolResultContent, type ToolResultDocumentContent, type ToolResultDocumentRefContent, type ToolResultImageContent, type ToolResultImageRefContent, type ToolResultMetadata, type ToolResultTextContent, type ToolResultVideoContent, type ToolSpec, type ToolStateController, type ToolStateOp, type ToolStateStore, type ToolStateView, type TurnFinishReason, type TurnResult, type TurnUsage, type ValidationResult, flattenTurns, matchesContextExceeded, statsByModel, toolOutputBudgetByteLength, toolOutputByteLength, toolResultToText };

package/dist/types.js

@@ -1,4 +1,4 @@
-import { c as toolOutputBudgetByteLength, l as toolOutputByteLength, t as DEFAULT_AGENT_CLOCK, u as toolResultToText } from "./types-CWgENVLY.js";
 import { a as AgentProviderError, c as CONTEXT_EXCEEDED_MESSAGE_PATTERNS, m as matchesContextExceeded, n as AgentBudgetExceededError, o as AgentToolNotAllowedError, r as AgentContextExceededError, t as AgentAbortedError } from "./errors-DKiMrOKq.js";
+import { d as toolResultToText, l as toolOutputBudgetByteLength, t as DEFAULT_AGENT_CLOCK, u as toolOutputByteLength } from "./types-Cu0ZGDu9.js";
 import { i as statsByModel, n as flattenTurns } from "./stats-DAKBEKjc.js";
 export { AgentAbortedError, AgentBudgetExceededError, AgentContextExceededError, AgentProviderError, AgentToolNotAllowedError, CONTEXT_EXCEEDED_MESSAGE_PATTERNS, DEFAULT_AGENT_CLOCK, flattenTurns, matchesContextExceeded, statsByModel, toolOutputBudgetByteLength, toolOutputByteLength, toolResultToText };