@wildo-ai/external-connectors-models 1.0.1 → 1.1.1

package/dist/esm/protocols/agent-client-protocol.external-connectors-models.schemas.d.ts

@@ -0,0 +1,526 @@
+import { z } from "zod";
+import { ExternalProvider_OperationDefinition_Base } from "../core/operations.external-connectors-models.schemas";
+import { APPLICATION_ENVIRONMENT, ExternalProvider_ExchangeProtocol_Configuration_Base, ExternalProvider_ExchangeProtocol_Kind, ExternalProvider_ExchangeProtocol_Profile_Base } from "../core/commons.external-connectors-models.schemas";
+/**
+ * Where the agent subprocess runs.
+ *
+ * Only one host exists today, and it is the same constraint the coding lane has
+ * always had: the agent must share a filesystem with the workspace it mutates.
+ * A remote host is not a variant of this — it would need the workspace shipped
+ * to it, which is a different design, so it is deliberately not enumerated
+ * until it exists.
+ */
+export declare enum AgentClientProtocol_RunnerHost {
+    BACKEND_SUBPROCESS = "backend_subprocess"
+}
+/**
+ * How the spawned agent authenticates to its own model provider.
+ *
+ * ACP additionally defines a protocol-level `authenticate` method, advertised
+ * through the agent's `authMethods` array. That is NOT enumerated here: when an
+ * agent advertises auth methods the runner negotiates them at `initialize`
+ * time, which is a runtime handshake rather than authored configuration. These
+ * modes describe what the HOST does before the process starts.
+ */
+export declare enum AgentClientProtocol_AuthMode {
+    /** The agent needs no credential (a local model, or an agent that refuses work). */
+    NONE = "none",
+    /**
+     * The agent resolves its own credential from host state — an operator's prior
+     * interactive login, a keychain entry, an ambient cloud identity. Wildo
+     * injects nothing and can see nothing. This is the correct mode for a
+     * developer-machine coding agent.
+     */
+    HOST_MANAGED = "host_managed",
+    /** Wildo resolves a secret by ref and injects it into the child environment. */
+    SECRET_REF_ENV_INJECTION = "secret_ref_env_injection"
+}
+/**
+ * Which directory becomes the ACP session's `cwd`.
+ *
+ * ACP requires `cwd` to be an ABSOLUTE path and treats it as the session's
+ * primary filesystem context. The absolute path itself is never authored here:
+ * it is host authority supplied at invocation time, which is what makes a
+ * profile portable across applications and machines.
+ */
+export declare enum AgentClientProtocol_WorkingDirectoryPolicy {
+    WORKSPACE_ROOT = "workspace_root",
+    WORKSPACE_RELATIVE_PATH = "workspace_relative_path"
+}
+/**
+ * The MOST autonomy a session started from this profile may be granted.
+ *
+ * This is a Wildo-owned vocabulary, deliberately expressed in terms of what the
+ * CLIENT must still decide rather than in any agent's mode identifiers. Agents
+ * advertise their own modes at `session/new` (Claude's adapter offers
+ * `default`, `auto`, `acceptEdits`, `plan`, `dontAsk`, `bypassPermissions`),
+ * and those identifiers are agent-specific strings — binding a provider profile
+ * to them would make the contract unusable for any other agent and would break
+ * the moment an agent renames one.
+ *
+ * It is a CEILING, not a selection: the caller (for application creation, the
+ * autonomy mode of the journey) chooses at or below it. An authored ceiling is
+ * what lets an application say "no session started from this profile may ever
+ * skip the permission gate" independently of what any individual run requests.
+ *
+ * Ordering is meaningful and increasing: PROMPT_ALWAYS < AUTO_ACCEPT_EDITS <
+ * UNRESTRICTED. Compare through {@link agentClientProtocolPermissionCeilingRank}
+ * rather than by string, so the ordering has one definition.
+ */
+export declare enum AgentClientProtocol_PermissionCeiling {
+    /**
+     * Every permission request the agent raises must be answered by the client.
+     *
+     * Note what this does and does not promise: it guarantees the CLIENT decides
+     * every request the agent RAISES, not that the agent raises one per action.
+     * Which tool calls escalate is the agent's own policy — measured against
+     * Claude's adapter, file edits and writes prompt while a read-only shell
+     * command does not. Treat this as "no blanket pre-approval", never as "a
+     * complete inventory of what the agent did"; that inventory comes from the
+     * tool-call stream and, authoritatively, from the change set.
+     */
+    PROMPT_ALWAYS = "prompt_always",
+    /**
+     * File edits are auto-accepted; everything else must still be answered.
+     *
+     * "Must still be answered" is a promise the CLIENT keeps, and it is only
+     * keepable because the runner refuses to hand the decision to the agent.
+     * Measured live against Claude's adapter on 2026-08-27: selecting that
+     * agent's own `acceptEdits` session mode ALSO auto-approves arbitrary shell
+     * commands, so a mutating `printf > file` executed with no permission request
+     * at all and wrote outside the task's declared mutation scope. Under the
+     * strictest mode the identical prompt escalated and was denied, and nothing
+     * was written.
+     *
+     * So this ceiling is implemented by keeping the agent in its most-escalating
+     * mode and auto-allowing edit-kind requests HERE. The agent's similarly named
+     * mode is deliberately not selected: it grants strictly more than its name.
+     */
+    AUTO_ACCEPT_EDITS = "auto_accept_edits",
+    /**
+     * The protocol's NON-MUTATING tool kinds are auto-accepted; everything else must still be
+     * answered — and with no human at the other end, that means denied.
+     *
+     * The read-only lane. `read`, `search`, `fetch` and `think` are exactly the kinds the Agent Client
+     * Protocol itself classes as non-mutating; `edit`, `delete` and `move` are its mutating set and are
+     * refused here, as are `execute` (which can mutate anything) and `other` (unclassified, so
+     * fail-closed).
+     *
+     * Added 2026-08-29 because neither existing ceiling could express a research agent, MEASURED
+     * rather than assumed: a probe under {@link PROMPT_ALWAYS} with every location refused had both
+     * `WebFetch` and `WebSearch` arrive as `toolKind: 'fetch'` and be `ceiling_refused`, and the agent
+     * ended its turn saying it would not guess a price from memory. So PROMPT_ALWAYS denies research
+     * outright, and {@link AUTO_ACCEPT_EDITS} admits precisely the inverse of what research needs.
+     */
+    AUTO_ACCEPT_READS = "auto_accept_reads",
+    /** No permission gate. Reserve for a disposable or isolated workspace. */
+    UNRESTRICTED = "unrestricted"
+}
+/**
+ * Increasing rank for {@link AgentClientProtocol_PermissionCeiling}; the single ordering definition.
+ *
+ * ## It is a CLAMP order, not a subset lattice — and that distinction is load-bearing
+ *
+ * Rank answers one question: how much is pre-approved without a human. It is used to LOWER a
+ * request that asks for more autonomy than its profile allows, never to reason about which
+ * permissions contain which.
+ *
+ * The sets are deliberately NOT nested. {@link AgentClientProtocol_PermissionCeiling.AUTO_ACCEPT_EDITS}
+ * (rank 2) admits the mutating kinds and still refuses `fetch`, while
+ * {@link AgentClientProtocol_PermissionCeiling.AUTO_ACCEPT_READS} (rank 1) admits `fetch` and refuses
+ * every mutating kind. Reading rank as containment would say the higher ceiling must also admit
+ * `fetch` — and making that true would hand every coding agent network access as a side effect of
+ * building a research lane. That is a change to the coding lane's posture and it needs its own
+ * evidence, not a corollary. Clamping still behaves correctly: a coding profile lowered to
+ * AUTO_ACCEPT_READS may fetch and may not edit, which is exactly what asking for less autonomy in
+ * the read direction should mean.
+ */
+export declare function agentClientProtocolPermissionCeilingRank(ceiling: AgentClientProtocol_PermissionCeiling): number;
+/**
+ * How much of the HOST MACHINE's agent configuration a session inherits.
+ *
+ * Coding agents read configuration from the filesystem — instructions, skills,
+ * slash commands, sub-agent personas, tool permissions — and they layer several
+ * scopes. Measured against Claude's ACP adapter, the default is to load ALL of
+ * them, including the operator's personal `~/.claude`: a probe session returned
+ * roughly forty commands and a persona belonging to the machine running it,
+ * none of which the application authored.
+ *
+ * That inheritance is not simply undesirable, which is why this is a three-way
+ * choice rather than a boolean. A dispatched coding task SHOULD read the
+ * application's own instructions and installed skills — that is how the
+ * application teaches the agent to use its framework. What it should not
+ * silently absorb is whoever happens to be logged in.
+ */
+export declare enum AgentClientProtocol_HostConfigurationInheritance {
+    /** No filesystem-sourced agent configuration. The prompt is the whole instruction. */
+    ISOLATED = "isolated",
+    /**
+     * Configuration owned by the workspace (its committed instructions, its
+     * installed skills, its checked-in settings) — but not the operator's
+     * personal configuration. The correct default for a dispatched task.
+     */
+    APPLICATION_SCOPED = "application_scoped",
+    /**
+     * Everything the agent would load if a human had started it by hand,
+     * including operator-level configuration. Honest about what it is: the run
+     * then depends on machine state Wildo neither authored nor recorded, so a run
+     * is not reproducible on another machine.
+     */
+    HOST_INHERITED = "host_inherited"
+}
+/**
+ * One authored way to start an ACP agent.
+ *
+ * Mirrors the shape a provider's execution profiles have always had: the
+ * spawnable command plus the policy that decides whether it may run at all.
+ */
+export declare const AgentClientProtocol_ExecutionProfileSchema: z.ZodObject<{
+    runnerHost: z.ZodDefault<z.ZodEnum<typeof AgentClientProtocol_RunnerHost>>;
+    command: z.ZodOptional<z.ZodString>;
+    args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    inheritedEnvironmentVariables: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    authMode: z.ZodEnum<typeof AgentClientProtocol_AuthMode>;
+    secretRef: z.ZodOptional<z.ZodString>;
+    secretEnvVarName: z.ZodOptional<z.ZodString>;
+    allowedApplicationEnvironments: z.ZodArray<z.ZodEnum<typeof APPLICATION_ENVIRONMENT>>;
+    allowedPlatformEnvironmentIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    workingDirectoryPolicy: z.ZodDefault<z.ZodEnum<typeof AgentClientProtocol_WorkingDirectoryPolicy>>;
+    workingDirectoryRelativePath: z.ZodOptional<z.ZodString>;
+    permissionCeiling: z.ZodDefault<z.ZodEnum<typeof AgentClientProtocol_PermissionCeiling>>;
+    hostConfigurationInheritance: z.ZodDefault<z.ZodEnum<typeof AgentClientProtocol_HostConfigurationInheritance>>;
+    turnTimeoutMs: z.ZodOptional<z.ZodNumber>;
+    maximumRecordedEventBytes: z.ZodOptional<z.ZodNumber>;
+    sessionMetaExtensions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strict>;
+export type AgentClientProtocol_ExecutionProfile = z.infer<typeof AgentClientProtocol_ExecutionProfileSchema>;
+/**
+ * Transport capability metadata for an ACP-speaking provider.
+ *
+ * Note how little is declared here compared with a one-shot CLI contract, and
+ * why: ACP agents advertise their own capabilities, session modes and available
+ * commands during `initialize` and `session/new`. Re-declaring any of that in
+ * authored configuration would create a second source of truth that drifts the
+ * first time the agent is upgraded. What remains is what the HOST must know
+ * before it opens a connection.
+ */
+export declare const AgentClientProtocol_ProfileSchema: z.ZodObject<{
+    endpoints: z.ZodOptional<z.ZodRecord<z.ZodEnum<typeof APPLICATION_ENVIRONMENT>, z.ZodString>>;
+    availableAuthMethods: z.ZodOptional<z.ZodArray<z.ZodEnum<typeof import("..").ExternalProvider_Auth_Kind>>>;
+    authProfiles: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        ref: z.ZodOptional<z.ZodString>;
+        isDefault: z.ZodDefault<z.ZodBoolean>;
+        location: z.ZodDefault<z.ZodEnum<typeof import("..").ExternalProvider_Auth_ApiKey_Location>>;
+        kind: z.ZodLiteral<import("..").ExternalProvider_Auth_Kind.API_KEY>;
+        locationField: z.ZodDefault<z.ZodString>;
+        prefix: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        ref: z.ZodOptional<z.ZodString>;
+        isDefault: z.ZodDefault<z.ZodBoolean>;
+        location: z.ZodDefault<z.ZodEnum<typeof import("..").ExternalProvider_Auth_ApiKey_Location>>;
+        kind: z.ZodLiteral<import("..").ExternalProvider_Auth_Kind.HMAC_SIGNATURE>;
+        locationField: z.ZodDefault<z.ZodString>;
+        algorithm: z.ZodDefault<z.ZodEnum<typeof import("..").ExternalProvider_Auth_HMAC_Signature_Algorithm>>;
+        signaturePayload: z.ZodOptional<z.ZodEnum<{
+            custom: "custom";
+            body: "body";
+            timestamp: "timestamp";
+        }>>;
+        timestampHeader: z.ZodOptional<z.ZodString>;
+        nonceHeader: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        ref: z.ZodOptional<z.ZodString>;
+        isDefault: z.ZodDefault<z.ZodBoolean>;
+        kind: z.ZodLiteral<import("..").ExternalProvider_Auth_Kind.BEARER>;
+        location: z.ZodDefault<z.ZodEnum<typeof import("..").ExternalProvider_Auth_ApiKey_Location>>;
+        locationField: z.ZodDefault<z.ZodString>;
+        prefix: z.ZodDefault<z.ZodString>;
+        format: z.ZodDefault<z.ZodEnum<typeof import("..").ExternalProvider_Auth_Bearer_Format>>;
+    }, z.core.$strip>, z.ZodObject<{
+        ref: z.ZodOptional<z.ZodString>;
+        isDefault: z.ZodDefault<z.ZodBoolean>;
+        location: z.ZodDefault<z.ZodEnum<typeof import("..").ExternalProvider_Auth_ApiKey_Location>>;
+        locationField: z.ZodDefault<z.ZodString>;
+        kind: z.ZodLiteral<import("..").ExternalProvider_Auth_Kind.OPENID_CONNECT>;
+        discoveryUrl: z.ZodOptional<z.ZodURL>;
+        issuer: z.ZodOptional<z.ZodString>;
+        audience: z.ZodOptional<z.ZodString>;
+        validationMode: z.ZodOptional<z.ZodEnum<{
+            jwks: "jwks";
+            introspection: "introspection";
+            local: "local";
+        }>>;
+    }, z.core.$strip>, z.ZodObject<{
+        ref: z.ZodOptional<z.ZodString>;
+        isDefault: z.ZodDefault<z.ZodBoolean>;
+        location: z.ZodDefault<z.ZodEnum<typeof import("..").ExternalProvider_Auth_ApiKey_Location>>;
+        locationField: z.ZodDefault<z.ZodString>;
+        kind: z.ZodLiteral<import("..").ExternalProvider_Auth_Kind.OAUTH2>;
+        oauth2ProviderRef: z.ZodOptional<z.ZodString>;
+        authUrl: z.ZodOptional<z.ZodURL>;
+        tokenUrl: z.ZodOptional<z.ZodURL>;
+        refreshUrl: z.ZodOptional<z.ZodURL>;
+        scopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        grantType: z.ZodOptional<z.ZodEnum<typeof import("./oauth2.external-connectors-models.schemas").OAuth2_GrantType>>;
+        tokenEndpointAuthMethod: z.ZodOptional<z.ZodEnum<typeof import("./oauth2.external-connectors-models.schemas").OAuth2_TokenEndpoint_AuthMethod>>;
+        pkce: z.ZodOptional<z.ZodBoolean>;
+        pkceMethod: z.ZodOptional<z.ZodEnum<typeof import("./oauth2.external-connectors-models.schemas").OAuth2_PKCE_Method>>;
+        prompt: z.ZodOptional<z.ZodEnum<typeof import("./oauth2.external-connectors-models.schemas").OAuth2_Prompt>>;
+        accessType: z.ZodOptional<z.ZodEnum<typeof import("./oauth2.external-connectors-models.schemas").OAuth2_AccessType>>;
+        extraAuthParams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        extraTokenParams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        tokenFormat: z.ZodDefault<z.ZodEnum<{
+            token: "token";
+            bearer: "bearer";
+            oauth: "oauth";
+            custom: "custom";
+        }>>;
+        customTokenPrefix: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        ref: z.ZodOptional<z.ZodString>;
+        isDefault: z.ZodDefault<z.ZodBoolean>;
+        location: z.ZodDefault<z.ZodEnum<typeof import("..").ExternalProvider_Auth_ApiKey_Location>>;
+        locationField: z.ZodDefault<z.ZodString>;
+        kind: z.ZodLiteral<import("..").ExternalProvider_Auth_Kind.BASIC>;
+        usernameRef: z.ZodOptional<z.ZodString>;
+        passwordRef: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        ref: z.ZodOptional<z.ZodString>;
+        isDefault: z.ZodDefault<z.ZodBoolean>;
+        location: z.ZodDefault<z.ZodEnum<typeof import("..").ExternalProvider_Auth_ApiKey_Location>>;
+        locationField: z.ZodDefault<z.ZodString>;
+        kind: z.ZodLiteral<import("..").ExternalProvider_Auth_Kind.NONE>;
+    }, z.core.$strip>, z.ZodObject<{
+        ref: z.ZodOptional<z.ZodString>;
+        isDefault: z.ZodDefault<z.ZodBoolean>;
+        location: z.ZodDefault<z.ZodEnum<typeof import("..").ExternalProvider_Auth_ApiKey_Location>>;
+        locationField: z.ZodDefault<z.ZodString>;
+        kind: z.ZodLiteral<import("..").ExternalProvider_Auth_Kind.FRONTEND_SECRET>;
+        frontendOnly: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodObject<{
+        ref: z.ZodOptional<z.ZodString>;
+        isDefault: z.ZodDefault<z.ZodBoolean>;
+        location: z.ZodDefault<z.ZodEnum<typeof import("..").ExternalProvider_Auth_ApiKey_Location>>;
+        locationField: z.ZodDefault<z.ZodString>;
+        kind: z.ZodLiteral<import("..").ExternalProvider_Auth_Kind.MUTUAL_TLS>;
+        certificateRef: z.ZodOptional<z.ZodString>;
+        privateKeyRef: z.ZodOptional<z.ZodString>;
+        caRef: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>], "kind">>>;
+    supportedRunnerHosts: z.ZodDefault<z.ZodArray<z.ZodEnum<typeof AgentClientProtocol_RunnerHost>>>;
+    supportedProtocolVersions: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
+    supportedOperationKeys: z.ZodArray<z.ZodString>;
+    supportedModels: z.ZodArray<z.ZodString>;
+    supportedAuthModes: z.ZodDefault<z.ZodArray<z.ZodEnum<typeof AgentClientProtocol_AuthMode>>>;
+}, z.core.$strip>;
+export type AgentClientProtocol_Profile = ExternalProvider_ExchangeProtocol_Profile_Base & z.infer<typeof AgentClientProtocol_ProfileSchema>;
+export declare const AgentClientProtocol_ConfigurationSchema: z.ZodObject<{
+    enabled: z.ZodBoolean;
+    authConfig: z.ZodOptional<z.ZodObject<{
+        authKind: z.ZodEnum<typeof import("..").ExternalProvider_Auth_Kind>;
+        profileRefs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        isDefault: z.ZodOptional<z.ZodBoolean>;
+        secretRef: z.ZodString;
+    }, z.core.$strip>>;
+    rateLimitConfig: z.ZodOptional<z.ZodObject<{
+        maxConcurrent: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        minTime: z.ZodOptional<z.ZodNumber>;
+        reservoir: z.ZodOptional<z.ZodNumber>;
+        reservoirRefreshInterval: z.ZodOptional<z.ZodNumber>;
+        reservoirRefreshAmount: z.ZodOptional<z.ZodNumber>;
+        priority: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    }, z.core.$strip>>;
+    defaultExecutionProfileRef: z.ZodOptional<z.ZodString>;
+    executionProfiles: z.ZodRecord<z.ZodString, z.ZodObject<{
+        runnerHost: z.ZodDefault<z.ZodEnum<typeof AgentClientProtocol_RunnerHost>>;
+        command: z.ZodOptional<z.ZodString>;
+        args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        inheritedEnvironmentVariables: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        authMode: z.ZodEnum<typeof AgentClientProtocol_AuthMode>;
+        secretRef: z.ZodOptional<z.ZodString>;
+        secretEnvVarName: z.ZodOptional<z.ZodString>;
+        allowedApplicationEnvironments: z.ZodArray<z.ZodEnum<typeof APPLICATION_ENVIRONMENT>>;
+        allowedPlatformEnvironmentIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        workingDirectoryPolicy: z.ZodDefault<z.ZodEnum<typeof AgentClientProtocol_WorkingDirectoryPolicy>>;
+        workingDirectoryRelativePath: z.ZodOptional<z.ZodString>;
+        permissionCeiling: z.ZodDefault<z.ZodEnum<typeof AgentClientProtocol_PermissionCeiling>>;
+        hostConfigurationInheritance: z.ZodDefault<z.ZodEnum<typeof AgentClientProtocol_HostConfigurationInheritance>>;
+        turnTimeoutMs: z.ZodOptional<z.ZodNumber>;
+        maximumRecordedEventBytes: z.ZodOptional<z.ZodNumber>;
+        sessionMetaExtensions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>>;
+}, z.core.$strip>;
+export type AgentClientProtocol_Configuration = ExternalProvider_ExchangeProtocol_Configuration_Base & z.infer<typeof AgentClientProtocol_ConfigurationSchema>;
+export declare const AgentClientProtocol_StatusSchema: z.ZodObject<{
+    status: z.ZodEnum<typeof import("..").ExternalProvider_Status>;
+    lastCheckedAt: z.ZodString;
+    errorReason: z.ZodOptional<z.ZodString>;
+    protocolKind: z.ZodLiteral<ExternalProvider_ExchangeProtocol_Kind.AGENT_CLIENT_PROTOCOL>;
+    negotiatedProtocolVersion: z.ZodOptional<z.ZodNumber>;
+    observedAgentName: z.ZodOptional<z.ZodString>;
+    observedAgentVersion: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type AgentClientProtocol_Status = z.infer<typeof AgentClientProtocol_StatusSchema>;
+export declare enum CodingAgent_OperationKey {
+    /** A bounded, scoped change to a workspace, performed by an autonomous agent. */
+    RUN_CODING_TASK = "coding.runCodingTask"
+}
+/**
+ * Why a prompt turn ended.
+ *
+ * The wire values are ACP's own — this is the thin boundary where the
+ * protocol's vocabulary is translated into a named one Wildo can branch on and
+ * explain. `CANCELLED` in particular must stay distinguishable from `END_TURN`:
+ * a cancelled run's partial change set is a different fact from a completed
+ * run's, and a lane that conflates them reports work as finished that was
+ * interrupted.
+ */
+export declare enum CodingAgent_StopReason {
+    /** The agent finished of its own accord. */
+    END_TURN = "end_turn",
+    /** The model's output limit was reached mid-work. */
+    MAX_TOKENS = "max_tokens",
+    /** The agent's own per-turn request budget was exhausted. */
+    MAX_TURN_REQUESTS = "max_turn_requests",
+    /** The model declined the task. */
+    REFUSAL = "refusal",
+    /** The client asked the session to stop, and the agent complied. */
+    CANCELLED = "cancelled",
+    /**
+     * WILDO'S OWN marker, not an ACP wire value: the agent reported a stop reason
+     * this protocol version does not define.
+     *
+     * It exists so an unknown value cannot discard evidence. The alternative —
+     * throwing — happens AFTER the turn, i.e. after the workspace has already been
+     * mutated, so it would turn a completed run into an error whose change set
+     * nobody records. Callers must treat this like `CANCELLED`: not a working
+     * result, but a run whose changes are real and must still be captured.
+     */
+    UNRECOGNISED = "wildo.unrecognised"
+}
+/**
+ * What one coding turn consumed.
+ *
+ * EVERY field is optional, and that is a statement about the protocol rather
+ * than laziness. ACP guarantees only the context-window pair (`used` / `size`)
+ * on its usage notification; token breakdowns and monetary cost are agent
+ * EXTENSIONS — Claude's adapter reports all of them, another agent may report
+ * none. Code that enforces a budget must therefore decide what to do when the
+ * number it wants is absent, and the schema makes that unavoidable rather than
+ * letting a missing value read as zero.
+ *
+ * This is the capability the transport it replaces could not express at all:
+ * a one-shot CLI reported nothing, so budgets were reduced to wall-clock and
+ * run-count proxies.
+ */
+export declare const CodingAgent_UsageSchema: z.ZodObject<{
+    contextUsed: z.ZodOptional<z.ZodNumber>;
+    contextWindowSize: z.ZodOptional<z.ZodNumber>;
+    inputTokens: z.ZodOptional<z.ZodNumber>;
+    outputTokens: z.ZodOptional<z.ZodNumber>;
+    cachedReadTokens: z.ZodOptional<z.ZodNumber>;
+    cachedWriteTokens: z.ZodOptional<z.ZodNumber>;
+    totalTokens: z.ZodOptional<z.ZodNumber>;
+    cost: z.ZodOptional<z.ZodObject<{
+        amount: z.ZodNumber;
+        currency: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type CodingAgent_Usage = z.infer<typeof CodingAgent_UsageSchema>;
+/**
+ * Transport metadata for a completed coding run.
+ *
+ * Note where this lives: WITH the coding-agent family, not in the LLM
+ * protocol's transport union. A coding run is not an LLM call with a different
+ * wire format, and recording it inside the LLM execution-metadata union would
+ * re-create, one layer down, exactly the mis-modelling this protocol exists to
+ * end.
+ */
+export declare const AgentClientProtocol_ExecutionTransportMetadataSchema: z.ZodObject<{
+    protocolKind: z.ZodLiteral<ExternalProvider_ExchangeProtocol_Kind.AGENT_CLIENT_PROTOCOL>;
+    providerRef: z.ZodString;
+    executionProfileRef: z.ZodString;
+    model: z.ZodOptional<z.ZodString>;
+    negotiatedProtocolVersion: z.ZodOptional<z.ZodNumber>;
+    agentName: z.ZodOptional<z.ZodString>;
+    agentVersion: z.ZodOptional<z.ZodString>;
+    sessionModeId: z.ZodOptional<z.ZodString>;
+    sessionId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type AgentClientProtocol_ExecutionTransportMetadata = z.infer<typeof AgentClientProtocol_ExecutionTransportMetadataSchema>;
+export declare const CodingAgent_OperationContext_BaseSchema: z.ZodObject<{
+    callTimestamp: z.ZodISODateTime;
+    callDuration: z.ZodOptional<z.ZodNumber>;
+    errorReason: z.ZodOptional<z.ZodString>;
+    usage: z.ZodOptional<z.ZodObject<{
+        contextUsed: z.ZodOptional<z.ZodNumber>;
+        contextWindowSize: z.ZodOptional<z.ZodNumber>;
+        inputTokens: z.ZodOptional<z.ZodNumber>;
+        outputTokens: z.ZodOptional<z.ZodNumber>;
+        cachedReadTokens: z.ZodOptional<z.ZodNumber>;
+        cachedWriteTokens: z.ZodOptional<z.ZodNumber>;
+        totalTokens: z.ZodOptional<z.ZodNumber>;
+        cost: z.ZodOptional<z.ZodObject<{
+            amount: z.ZodNumber;
+            currency: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    executionTime: z.ZodOptional<z.ZodNumber>;
+    finishedAt: z.ZodOptional<z.ZodString>;
+    transport: z.ZodOptional<z.ZodObject<{
+        protocolKind: z.ZodLiteral<ExternalProvider_ExchangeProtocol_Kind.AGENT_CLIENT_PROTOCOL>;
+        providerRef: z.ZodString;
+        executionProfileRef: z.ZodString;
+        model: z.ZodOptional<z.ZodString>;
+        negotiatedProtocolVersion: z.ZodOptional<z.ZodNumber>;
+        agentName: z.ZodOptional<z.ZodString>;
+        agentVersion: z.ZodOptional<z.ZodString>;
+        sessionModeId: z.ZodOptional<z.ZodString>;
+        sessionId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type CodingAgent_OperationContext_Base = z.infer<typeof CodingAgent_OperationContext_BaseSchema>;
+export type CodingAgent_OperationDefinitionBase = ExternalProvider_OperationDefinition_Base & {
+    operationContextSchema: typeof CodingAgent_OperationContext_BaseSchema;
+    supportedModels?: string[];
+};
+/**
+ * Model-selection configuration for a coding agent.
+ *
+ * Deliberately smaller than its LLM sibling, and the omissions are the design.
+ * There is no `temperature`, `topP` or penalty here: those tune a completion,
+ * and an ACP agent is not one — it runs its own inner loop, chooses its own
+ * tools and manages its own sampling. Offering an application knobs the
+ * transport cannot honour would be worse than offering none, because it would
+ * read as configuration and behave as decoration.
+ *
+ * `maxTokens` is likewise absent: a coding run's budget is enforced by the
+ * caller against reported usage after each turn, not requested up front — the
+ * agent decides how many model calls its task needs.
+ */
+export declare const CodingAgent_OperationModelConfiguration_Schema: z.ZodObject<{
+    model: z.ZodString;
+    providerRef: z.ZodString;
+}, z.core.$strip>;
+export type CodingAgent_OperationModelConfiguration = z.infer<typeof CodingAgent_OperationModelConfiguration_Schema>;
+export declare const CodingAgent_RunTaskInputSchema: z.ZodObject<{
+    prompt: z.ZodString;
+    requestedPermissionCeiling: z.ZodOptional<z.ZodEnum<typeof AgentClientProtocol_PermissionCeiling>>;
+}, z.core.$strip>;
+export type CodingAgent_RunTaskInput = z.infer<typeof CodingAgent_RunTaskInputSchema>;
+export declare const CodingAgent_RunTaskOutputSchema: z.ZodObject<{
+    finalMessage: z.ZodString;
+    stopReason: z.ZodEnum<typeof CodingAgent_StopReason>;
+    reportedFileLocations: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    deniedPermissionCount: z.ZodOptional<z.ZodNumber>;
+    permissionDecisions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        allowed: z.ZodBoolean;
+        reason: z.ZodString;
+        toolKind: z.ZodOptional<z.ZodString>;
+        locations: z.ZodArray<z.ZodString>;
+        offeredOptionKinds: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>>;
+    rawStopReason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type CodingAgent_RunTaskOutput = z.infer<typeof CodingAgent_RunTaskOutputSchema>;
+//# sourceMappingURL=agent-client-protocol.external-connectors-models.schemas.d.ts.map

package/dist/esm/protocols/agent-client-protocol.external-connectors-models.schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-client-protocol.external-connectors-models.schemas.d.ts","sourceRoot":"","sources":["../../../../src/protocols/agent-client-protocol.external-connectors-models.schemas.ts"],"names":[],"mappings":"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"}