@wildo-ai/external-connectors-models 1.1.3 → 1.1.5

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

@@ -1,6 +1,6 @@
 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";
+import { APPLICATION_ENVIRONMENT, ExternalProvider_ExchangeProtocol_Configuration_Base, ExternalProvider_ExchangeProtocol_Kind } from "../core/commons.external-connectors-models.schemas";
 /**
  * Where the agent subprocess runs.
  *
@@ -63,17 +63,9 @@ export declare enum AgentClientProtocol_WorkingDirectoryPolicy {
  * 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 over all FIVE members: PROMPT_ALWAYS <
- * AUTO_ACCEPT_READS < AUTO_ACCEPT_EDITS < AUTO_ACCEPT_READS_AND_EDITS <
- * UNRESTRICTED. Compare through {@link agentClientProtocolPermissionCeilingRank}
- * rather than by string, so the ordering has one definition.
- *
- * Read that order as a CLAMP — how much is pre-approved without a human — and never
- * as containment. The ceilings are kind-SETS and are deliberately not nested:
- * AUTO_ACCEPT_EDITS outranks AUTO_ACCEPT_READS and still refuses `fetch`, which is
- * exactly why AUTO_ACCEPT_READS_AND_EDITS had to be added rather than being implied
- * by the higher rank. Each member's own docstring states the set it admits, and the
- * rank function carries the full argument for why containment is the wrong reading.
+ * Policies describe admitted tool-kind sets, not nested levels. Invocation overrides
+ * intersect those sets with the profile: READS and EDITS have an empty intersection.
+ * The rank helper is a presentation ordering only and must not select authority.
  */
 /** @wildo_source:part:start acp.permission-ceiling facet:layer:config facet:audience:app-developer */
 export declare enum AgentClientProtocol_PermissionCeiling {
@@ -140,28 +132,42 @@ export declare enum AgentClientProtocol_PermissionCeiling {
      * can fetch anything and write only its evidence directory.
      */
     AUTO_ACCEPT_READS_AND_EDITS = "auto_accept_reads_and_edits",
-    /** No permission gate. Reserve for a disposable or isolated workspace. */
+    /**
+     * No permission gate: every tool kind is pre-approved, `execute` and the unclassified `other`
+     * included. Reserve for a disposable or isolated workspace.
+     *
+     * **This member also removes the task's mutation scope for shell commands, and that is a property
+     * of shell commands rather than of this value.** The scope predicate runs AFTER the ceiling and
+     * denies any location the task did not authorise even here — so declared file EDITS stay confined.
+     * But it decides on the `locations` a permission request carries, and a shell command carries
+     * NONE, because what a command writes is not derivable from the command string. Every ceiling
+     * below this one refuses `execute` outright, so the empty-location case never reaches the
+     * predicate; under this one it does, and `locations.some(...)` over an empty array is vacuously
+     * satisfied. A mutating command therefore reaches the workspace inside a complete, well-formed
+     * permission record showing it was allowed.
+     *
+     * Not closable by deriving a scope from the command: any parse is defeated by `sh -c "$CMD"` or a
+     * redirect through a substituted path, and an invented scope that can be walked around is worse
+     * than a stated absence. So the residual exposure under this member is exactly "shell commands are
+     * unbounded", the answer to it is git plus the post-run change set, and the companion WARNS on
+     * every run whose mutation followed a permitted act that declared no location — which is how it
+     * stops being invisible. Author this member to state that plainly; do not author it expecting the
+     * mutation scope to hold for commands.
+     *
+     * Note this is a DIFFERENT hole from an agent that never asks (see
+     * {@link AgentClientProtocol_PermissionEscalationBehaviour}): that one costs you both guards for
+     * every act, and dispatch refuses a narrower ceiling against such an agent. This one costs you the
+     * scope guard for one act kind, against a fully compliant agent.
+     */
     UNRESTRICTED = "unrestricted"
 }
 /** @wildo_source:part:end acp.permission-ceiling */
 /**
- * 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.
+ * Stable presentation order for {@link AgentClientProtocol_PermissionCeiling}.
+ *
+ * Never use this rank to authorize or clamp a request. READS and EDITS admit disjoint
+ * tool-kind sets; choosing the numerically lower one can grant operations forbidden
+ * by the profile. Dispatch computes their intersection instead.
  */
 export declare function agentClientProtocolPermissionCeilingRank(ceiling: AgentClientProtocol_PermissionCeiling): number;
 /**
@@ -170,11 +176,12 @@ export declare function agentClientProtocolPermissionCeilingRank(ceiling: AgentC
  *
  * # Why a permission ceiling needs this to mean anything
  *
- * Both of Wildo's in-flight controls are enforced in the CLIENT's ANSWER to a
+ * For agent-owned I/O, Wildo's in-flight controls are enforced in the CLIENT's ANSWER to a
  * permission request: {@link AgentClientProtocol_PermissionCeiling} decides the
  * tool KIND, and the dispatch's location predicate decides the PATHS. Neither is
  * a sandbox, an interposed filesystem, or a syscall filter — they are answers.
- * So an agent that writes without asking is bound by neither, and the ceiling
+ * Client-hosted writes independently check both controls. An agent doing its OWN I/O
+ * without asking is bound by neither, and the ceiling
  * an application authored is a LABEL rather than a guarantee.
  *
  * That is not hypothetical and it is not a fault in the agents. MEASURED with
@@ -288,6 +295,47 @@ export declare enum AgentClientProtocol_HostConfigurationInheritance {
     HOST_INHERITED = "host_inherited"
 }
 /** @wildo_source:part:end acp.host-configuration-inheritance */
+/** @wildo_source:part:start acp.execution-profile facet:layer:config facet:audience:app-developer */
+/**
+ * WHERE a coding run's content actually goes, per MODEL (issue #308, join 2).
+ *
+ * An ACP coding session sends the composed task prompt, retrieved context and — through the agent's
+ * own file reads — the application's SOURCE CODE to the selected model vendor. For an application
+ * built with Wildo that can include the customer's domain model, schemas, seed data shapes and
+ * business rules. So the destination is a processor-register fact, not a runtime detail.
+ *
+ * ## Why this is per MODEL and not per provider
+ *
+ * A generalist agent routes to several vendors, so its OWN legal identity is not the identity of the
+ * vendor a given run reaches: OpenCode is a binary on the host, and the same profile can send code to
+ * Anthropic or to OpenAI depending on one model id. A per-provider declaration structurally cannot
+ * express that — it would name the agent's publisher as the recipient of code the publisher never
+ * receives, which is false in the direction a reader cannot check.
+ *
+ * ## Why it lives on the EXECUTION PROFILE
+ *
+ * The profile is already where an application authors the policy it owns, and the model is selected at
+ * dispatch time against that profile. The competing home — `providerComplianceChoices`, where every
+ * other compliance answer lives — cannot carry it: that surface is keyed by provider ref and has one
+ * entry per provider, which is exactly the shape that cannot say "per model".
+ *
+ * `ApplicationProviderComplianceChoice` warns against putting a compliance answer somewhere "nothing
+ * can read it without knowing the provider", and `providerConfigurations` is genuinely an opaque
+ * `Record<string, unknown>` bag. That objection is answered rather than ignored:
+ * {@link readCodingModelDestinations} is the named reader, exported beside this schema, and the
+ * compliance renderer calls it instead of reaching into the bag and guessing a shape. The hazard the
+ * warning names is a fact nobody can FIND; a named reader is what removes it.
+ */
+export declare const AgentClientProtocol_ModelDestinationSchema: z.ZodObject<{
+    vendorLegalEntityName: z.ZodString;
+    processingRegions: z.ZodArray<z.ZodString>;
+    gateway: z.ZodOptional<z.ZodObject<{
+        legalEntityName: z.ZodString;
+        processingRegions: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strict>;
+export type AgentClientProtocol_ModelDestination = z.infer<typeof AgentClientProtocol_ModelDestinationSchema>;
+/** @wildo_source:part:end acp.execution-profile */
 /**
  * One authored way to start an ACP agent.
  *
@@ -313,130 +361,18 @@ export declare const AgentClientProtocol_ExecutionProfileSchema: z.ZodObject<{
     maxAutoContinuations: z.ZodDefault<z.ZodNumber>;
     awaitingInputTtlMs: z.ZodDefault<z.ZodNumber>;
     maximumRecordedEventBytes: z.ZodOptional<z.ZodNumber>;
+    modelDestinations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        vendorLegalEntityName: z.ZodString;
+        processingRegions: z.ZodArray<z.ZodString>;
+        gateway: z.ZodOptional<z.ZodObject<{
+            legalEntityName: z.ZodString;
+            processingRegions: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strict>>>;
     sessionMetaExtensions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, z.core.$strict>;
 export type AgentClientProtocol_ExecutionProfile = z.infer<typeof AgentClientProtocol_ExecutionProfileSchema>;
 /** @wildo_source:part:end acp.execution-profile */
-/**
- * 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<{
-            custom: "custom";
-            bearer: "bearer";
-            token: "token";
-            oauth: "oauth";
-        }>>;
-        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<{
@@ -472,20 +408,18 @@ export declare const AgentClientProtocol_ConfigurationSchema: z.ZodObject<{
         maxAutoContinuations: z.ZodDefault<z.ZodNumber>;
         awaitingInputTtlMs: z.ZodDefault<z.ZodNumber>;
         maximumRecordedEventBytes: z.ZodOptional<z.ZodNumber>;
+        modelDestinations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            vendorLegalEntityName: z.ZodString;
+            processingRegions: z.ZodArray<z.ZodString>;
+            gateway: z.ZodOptional<z.ZodObject<{
+                legalEntityName: z.ZodString;
+                processingRegions: z.ZodArray<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strict>>>;
         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"
@@ -600,7 +534,13 @@ export declare const CodingAgent_SessionSuspensionSchema: z.ZodObject<{
      * context — a degradation the caller should surface, not hide.
      */
     resumable: z.ZodBoolean;
-    /** When the parked child process will be closed (ISO timestamp). */
+    /**
+     * An INFORMATIONAL freshness bound for the question (ISO timestamp), surfaced to the operator —
+     * never a reaping deadline. No child process is held open while a run is parked (see
+     * `awaitingInputTtlMs`), so there is nothing that closes at this instant. It said "when the parked
+     * child process will be closed" until 2026-09-24, contradicting the contract above it, and a host
+     * read it that way and aborted answerable questions at boot (#1533).
+     */
     parkedUntil: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
 export type CodingAgent_SessionSuspension = z.infer<typeof CodingAgent_SessionSuspensionSchema>;
@@ -757,9 +697,72 @@ export declare const CodingAgent_RunTaskOutputSchema: z.ZodObject<{
          * context — a degradation the caller should surface, not hide.
          */
         resumable: z.ZodBoolean;
-        /** When the parked child process will be closed (ISO timestamp). */
+        /**
+         * An INFORMATIONAL freshness bound for the question (ISO timestamp), surfaced to the operator —
+         * never a reaping deadline. No child process is held open while a run is parked (see
+         * `awaitingInputTtlMs`), so there is nothing that closes at this instant. It said "when the parked
+         * child process will be closed" until 2026-09-24, contradicting the contract above it, and a host
+         * read it that way and aborted answerable questions at boot (#1533).
+         */
         parkedUntil: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>;
 }, z.core.$strip>;
 export type CodingAgent_RunTaskOutput = z.infer<typeof CodingAgent_RunTaskOutputSchema>;
+/**
+ * One declared coding destination, joined to the provider and profile that declare it.
+ *
+ * Flat rather than nested because every consumer so far wants to enumerate destinations, not walk a
+ * tree — and a nested shape makes "which provider declares nothing" a hole a caller has to notice
+ * rather than a row it is handed. {@link CodingModelDestinationReading} carries both.
+ */
+export interface CodingModelDestinationEntry {
+    readonly providerRef: string;
+    readonly executionProfileRef: string;
+    readonly model: string;
+    readonly destination: AgentClientProtocol_ModelDestination;
+}
+/** What {@link readCodingModelDestinations} found, including what it found MISSING. */
+export interface CodingModelDestinationReading {
+    /** Every declared destination, sorted by provider, profile then model. */
+    readonly destinations: readonly CodingModelDestinationEntry[];
+    /**
+     * Profiles that can run a coding agent and declare NO destination at all.
+     *
+     * Reported as its own list rather than as an absence, because this is the gap a compliance brief
+     * must name: a run through such a profile sends source code somewhere the register cannot describe.
+     */
+    readonly profilesWithoutDestinations: readonly {
+        readonly providerRef: string;
+        readonly executionProfileRef: string;
+    }[];
+}
+/**
+ * Read per-model coding destinations out of an application's provider configurations.
+ *
+ * ## Why this function exists at all
+ *
+ * `providerConfigurations` is `Record<string, Record<string, unknown>>` — genuinely opaque, and
+ * `ApplicationProviderComplianceChoice` warns for that reason that "a compliance answer must not live
+ * somewhere nothing can read it without knowing the provider". The destination has to live there
+ * anyway (it is per MODEL, and no per-provider surface can hold it), so the objection is answered by
+ * making the reader NAMED and exported beside the schema instead of leaving each consumer to reach in
+ * and guess a shape. A compliance renderer calls this; it never parses the bag.
+ *
+ * ## What it does with malformed input
+ *
+ * SKIPS it, silently, and this is deliberate rather than lax. The function's job is to report what an
+ * application declared, and it is called from a compliance BRIEF — a lane that must not fail because
+ * one provider's opaque configuration has an unexpected shape. A profile whose destinations do not
+ * parse contributes nothing and therefore surfaces in `profilesWithoutDestinations`, which is the
+ * honest reading: nothing usable was declared.
+ *
+ * Nothing is lost by that leniency, because a malformed profile is ALREADY refused where it matters:
+ * `getAgentClientProtocolExecutionProfile` parses every profile through
+ * {@link AgentClientProtocol_ExecutionProfileSchema} when a run resolves one, and throws
+ * `ErrorType.CONFIGURATION` naming the provider and profile. So a bad destination fails the CODING RUN
+ * loudly, with an author present, while the compliance brief still reports the other twenty providers.
+ * Two surfaces, two correct answers — and note that the profile schema is `.strict()`, so before
+ * `modelDestinations` existed as a declared field an application COULD NOT have authored it at all.
+ */
+export declare function readCodingModelDestinations(providerConfigurations: Readonly<Record<string, unknown>>): CodingModelDestinationReading;
 //# 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

@@ -1 +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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"}
+{"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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"}