@tangle-network/cli-agent-registry 0.0.0-stage → 0.14.0

package/dist/index.d.mts

@@ -0,0 +1,1400 @@
+import { a as isBackendType, i as backendTypeSchema, n as BACKEND_TYPE, o as parseBackendType, r as BackendType, t as ALL_BACKEND_TYPES } from "./backend-types-CJH-wHS3.mjs";
+import { LocalCliAuthFile, materializeCliAuthBundle } from "./cli-auth-bundle.mjs";
+import { A as CliDirLayout, C as ProviderPhase, D as harnessModelSupportFor, E as cliAgentEnvRoleName, M as DEFAULT_CLI_DIR_LAYOUT, N as mergeCliDirLayout, O as harnessModelWire, S as ProviderLogger, T as cliAgentClaimEnvVarNames, _ as CliAgentModelWire, a as agentProfileSchema, b as CliAuthHome, c as cliAgentHostPassthroughEnvVarNames, d as AdapterFactory, f as CliAgentBuiltinTool, g as CliAgentEnvVars, h as CliAgentEnvExtraRole, i as MANAGED_MODEL_KEY_NAME_ENV_VAR, j as CliDirLayoutAdditions, k as SYNTHETIC_ROUTER_MODEL, l as getSpec, m as CliAgentEnvExtraParser, n as CLI_AGENT_SPECS, o as claimDeliverableEnvVarNames, p as CliAgentEnvExtra, r as MANAGED_MODEL_KEY_ENV_VAR, s as cliAgentEnvVarNamesByRole, t as AGENT_BACKEND_ENV_VAR, u as messageStorageDirOf, v as CliAgentRuntimeSpec, w as canonicalModelSlug, x as HarnessSpecCapabilities, y as CliAgentSpec } from "./specs-BSELpX1h.mjs";
+import { _ as substituteNativeSessionId, a as NativeSessionIdentity, c as SessionFormatId, d as assertStoreLocationHonoursSessionContract, f as compileSessionStoreGlob, g as sessionStoreForPath, h as sessionContractProblems, i as HarnessSessionEvidence, l as assertArgvHonoursSessionContract, m as normalizePosixPath, n as HarnessSessionContractError, o as NativeSessionStore, p as forbiddenArgViolations, r as HarnessSessionContractErrorCode, s as SESSION_FORMAT_IDS, t as HarnessSessionContract, u as assertFlagsHonourSessionContract } from "./session-contract-BC75JdnA.mjs";
+import { resolveDefaultBackend } from "./default-backend.mjs";
+import { describeLocalCliAuthExpectation, discoverLocalCliAuthFiles } from "./local-cli-auth.mjs";
+import { HARNESS_CONFORMANCE_PENDING, HARNESS_SESSION_UNSUPPORTED, NATIVE_SESSION_CONTRACTS, configDirHomeEnv } from "./native-session-contracts.mjs";
+import { MANAGED_MODEL_LADDER, ManagedModelChain, ManagedModelChainOptions, ManagedModelRung, SkippedManagedModel, bareModelId, isServableManagedModel, managedModelChain } from "./servable-models.mjs";
+import * as _$_tangle_network_agent_interface0 from "@tangle-network/agent-interface";
+import { z } from "zod";
+
+//#region src/adapter-bindings.d.ts
+interface AdapterRegistry {
+  registerAdapterFactory(name: string, factory: AdapterFactory, options?: {
+    force?: boolean;
+  }): void;
+  unregisterAdapterFactory(name: string): boolean;
+  getAdapterFactory(name: string): AdapterFactory | undefined;
+  listRegisteredAdapters(): string[];
+  assertAdaptersWired(): void;
+}
+/**
+ * A composition-owned factory map. Wiring requirements come from this selected
+ * catalog, not every harness known elsewhere. No provider implementation is
+ * imported here, and separate registries cannot overwrite each other's bindings.
+ *
+ * Registration itself does not authorize execution. As with the existing API,
+ * factories may be staged before catalog admission; callers must still resolve
+ * a selected spec and enforce its capabilities before dispatching a request.
+ * Unregistering a required factory is not retirement: select a new composition
+ * after draining its sessions rather than weakening the wiring invariant.
+ */
+declare function createAdapterRegistry(specs: readonly CliAgentSpec[]): AdapterRegistry;
+declare function registerAdapterFactory(name: string, factory: AdapterFactory, options?: {
+  force?: boolean;
+}): void;
+declare function unregisterAdapterFactory(name: string): boolean;
+declare function getAdapterFactory(name: string): AdapterFactory | undefined;
+declare function listRegisteredAdapters(): string[];
+declare function assertAdaptersWired(): void;
+//#endregion
+//#region src/agent-run-request.d.ts
+/**
+ * Agent run request fields shared by the orchestrator proxy
+ * (`agentExecuteRequestSchema`) and the sidecar (`agentRunRequestSchema`).
+ * The proxy parses and reserializes the body, so a field missing on one end
+ * is dropped or refused before the other end sees it. Each end keeps only
+ * its delta: strictness, OpenAPI metadata, the sidecar's `identifier` alias
+ * and its cliAuth refinement.
+ */
+type AgentRunBackend<Shape extends z.ZodRawShape> = z.infer<z.ZodObject<Shape>> & {
+  profile?: z.infer<typeof agentProfileSchema>;
+  profileSha256?: string;
+};
+/** A backend carries an inline profile, a profile digest, or neither. */
+declare function agentRunBackendVariants<Shape extends z.ZodRawShape>(base: Shape): z.ZodUnion<readonly [z.ZodObject<Shape & {
+  profile: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    version: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    prompt: z.ZodOptional<z.ZodObject<{
+      systemPrompt: z.ZodOptional<z.ZodString>;
+      appendSystemPrompt: z.ZodOptional<z.ZodString>;
+      instructions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    model: z.ZodOptional<z.ZodObject<{
+      default: z.ZodOptional<z.ZodString>;
+      small: z.ZodOptional<z.ZodString>;
+      provider: z.ZodOptional<z.ZodString>;
+      reasoningEffort: z.ZodOptional<z.ZodEnum<{
+        none: "none";
+        minimal: "minimal";
+        low: "low";
+        medium: "medium";
+        high: "high";
+        xhigh: "xhigh";
+        ultracode: "ultracode";
+      }>>;
+      maxVisibleOutputTokens: z.ZodOptional<z.ZodNumber>;
+      maxReasoningTokens: z.ZodOptional<z.ZodNumber>;
+      maxTotalOutputTokens: z.ZodOptional<z.ZodNumber>;
+      metadata: z.ZodOptional<z.ZodType<Record<string, unknown>, unknown, z.core.$ZodTypeInternals<Record<string, unknown>, unknown>>>;
+    }, z.core.$strict>>;
+    harness: z.ZodOptional<z.ZodEnum<{
+      "claude-code": "claude-code";
+      nanoclaw: "nanoclaw";
+      codex: "codex";
+      opencode: "opencode";
+      "kimi-code": "kimi-code";
+      pi: "pi";
+      prime: "prime";
+      gemini: "gemini";
+      hermes: "hermes";
+      openclaw: "openclaw";
+      amp: "amp";
+      "factory-droids": "factory-droids";
+      forge: "forge";
+      cursor: "cursor";
+      acp: "acp";
+      "cli-base": "cli-base";
+    }>>;
+    seats: z.ZodOptional<z.ZodArray<z.ZodObject<{
+      harness: z.ZodEnum<{
+        "claude-code": "claude-code";
+        nanoclaw: "nanoclaw";
+        codex: "codex";
+        opencode: "opencode";
+        "kimi-code": "kimi-code";
+        pi: "pi";
+        prime: "prime";
+        gemini: "gemini";
+        hermes: "hermes";
+        openclaw: "openclaw";
+        amp: "amp";
+        "factory-droids": "factory-droids";
+        forge: "forge";
+        cursor: "cursor";
+        acp: "acp";
+        "cli-base": "cli-base";
+      }>;
+      provider: z.ZodString;
+      model: z.ZodString;
+      reasoningEffort: z.ZodOptional<z.ZodEnum<{
+        none: "none";
+        minimal: "minimal";
+        low: "low";
+        medium: "medium";
+        high: "high";
+        xhigh: "xhigh";
+        ultracode: "ultracode";
+      }>>;
+      selector: z.ZodUnion<readonly [z.ZodObject<{
+        kind: z.ZodLiteral<"all-eligible">;
+      }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"seat">;
+        id: z.ZodString;
+      }, z.core.$strict>]>;
+      tools: z.ZodOptional<z.ZodType<Record<string, boolean>, unknown, z.core.$ZodTypeInternals<Record<string, boolean>, unknown>>>;
+      permissions: z.ZodOptional<z.ZodType<Record<string, "allow" | "ask" | "deny" | Record<string, "allow" | "ask" | "deny">>, unknown, z.core.$ZodTypeInternals<Record<string, "allow" | "ask" | "deny" | Record<string, "allow" | "ask" | "deny">>, unknown>>>;
+    }, z.core.$strict>>>;
+    proxySecrets: z.ZodOptional<z.ZodArray<z.ZodObject<{
+      hosts: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+      methods: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+      paths: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+      envName: z.ZodString;
+      secretRef: z.ZodObject<{
+        key: z.ZodString;
+        kind: z.ZodLiteral<"secret-ref">;
+      }, z.core.$strict>;
+      presentation: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"bearer">;
+      }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"basic">;
+        username: z.ZodString;
+      }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"header">;
+        name: z.ZodString;
+      }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"query">;
+        name: z.ZodString;
+      }, z.core.$strict>], "type">;
+      placeholderFormat: z.ZodOptional<z.ZodEnum<{
+        jwt: "jwt";
+        opaque: "opaque";
+      }>>;
+      ttlSeconds: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>>;
+    permissions: z.ZodOptional<z.ZodType<Record<string, "allow" | "ask" | "deny" | Record<string, "allow" | "ask" | "deny">>, unknown, z.core.$ZodTypeInternals<Record<string, "allow" | "ask" | "deny" | Record<string, "allow" | "ask" | "deny">>, unknown>>>;
+    tools: z.ZodOptional<z.ZodType<Record<string, boolean>, unknown, z.core.$ZodTypeInternals<Record<string, boolean>, unknown>>>;
+    mcp: z.ZodOptional<z.ZodType<Record<string, _$_tangle_network_agent_interface0.AgentProfileMcpServer>, unknown, z.core.$ZodTypeInternals<Record<string, _$_tangle_network_agent_interface0.AgentProfileMcpServer>, unknown>>>;
+    connections: z.ZodOptional<z.ZodArray<z.ZodObject<{
+      connectionId: z.ZodString;
+      capabilities: z.ZodArray<z.ZodString>;
+      alias: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    subagents: z.ZodOptional<z.ZodType<Record<string, {
+      description?: string | undefined;
+      prompt?: string | undefined;
+      model?: string | undefined;
+      tools?: Record<string, boolean> | undefined;
+      permissions?: Record<string, "allow" | "ask" | "deny" | Record<string, "allow" | "ask" | "deny">> | undefined;
+      maxSteps?: number | undefined;
+      metadata?: Record<string, unknown> | undefined;
+    }>, unknown, z.core.$ZodTypeInternals<Record<string, {
+      description?: string | undefined;
+      prompt?: string | undefined;
+      model?: string | undefined;
+      tools?: Record<string, boolean> | undefined;
+      permissions?: Record<string, "allow" | "ask" | "deny" | Record<string, "allow" | "ask" | "deny">> | undefined;
+      maxSteps?: number | undefined;
+      metadata?: Record<string, unknown> | undefined;
+    }>, unknown>>>;
+    resources: z.ZodOptional<z.ZodObject<{
+      knowledge: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        sourceId: z.ZodString;
+        generation: z.ZodString;
+      }, z.core.$strict>>>;
+      files: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        resource: z.ZodUnion<readonly [z.ZodObject<{
+          kind: z.ZodLiteral<"inline">;
+          name: z.ZodString;
+          content: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+          kind: z.ZodLiteral<"github">;
+          repository: z.ZodOptional<z.ZodString>;
+          path: z.ZodString;
+          ref: z.ZodOptional<z.ZodString>;
+          name: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>]>;
+        executable: z.ZodOptional<z.ZodBoolean>;
+      }, z.core.$strict>>>;
+      tools: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        kind: z.ZodLiteral<"inline">;
+        name: z.ZodString;
+        content: z.ZodString;
+      }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"github">;
+        repository: z.ZodOptional<z.ZodString>;
+        path: z.ZodString;
+        ref: z.ZodOptional<z.ZodString>;
+        name: z.ZodOptional<z.ZodString>;
+      }, z.core.$strict>]>>>;
+      skills: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        kind: z.ZodLiteral<"inline">;
+        name: z.ZodString;
+        content: z.ZodString;
+      }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"github">;
+        repository: z.ZodOptional<z.ZodString>;
+        path: z.ZodString;
+        ref: z.ZodOptional<z.ZodString>;
+        name: z.ZodOptional<z.ZodString>;
+      }, z.core.$strict>]>>>;
+      agents: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        kind: z.ZodLiteral<"inline">;
+        name: z.ZodString;
+        content: z.ZodString;
+      }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"github">;
+        repository: z.ZodOptional<z.ZodString>;
+        path: z.ZodString;
+        ref: z.ZodOptional<z.ZodString>;
+        name: z.ZodOptional<z.ZodString>;
+      }, z.core.$strict>]>>>;
+      commands: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        kind: z.ZodLiteral<"inline">;
+        name: z.ZodString;
+        content: z.ZodString;
+      }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"github">;
+        repository: z.ZodOptional<z.ZodString>;
+        path: z.ZodString;
+        ref: z.ZodOptional<z.ZodString>;
+        name: z.ZodOptional<z.ZodString>;
+      }, z.core.$strict>]>>>;
+      instructions: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+        kind: z.ZodLiteral<"inline">;
+        name: z.ZodString;
+        content: z.ZodString;
+      }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"github">;
+        repository: z.ZodOptional<z.ZodString>;
+        path: z.ZodString;
+        ref: z.ZodOptional<z.ZodString>;
+        name: z.ZodOptional<z.ZodString>;
+      }, z.core.$strict>]>]>>;
+      failOnError: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    hooks: z.ZodOptional<z.ZodType<Record<string, {
+      command: string;
+      timeoutMs?: number | undefined;
+      blocking?: boolean | undefined;
+      matcher?: string | undefined;
+      env?: Record<string, {
+        kind: "secret-ref";
+        key: string;
+        format?: "raw" | "bearer" | undefined;
+      } | {
+        kind: "public";
+        value: string;
+      }> | undefined;
+    }[]>, unknown, z.core.$ZodTypeInternals<Record<string, {
+      command: string;
+      timeoutMs?: number | undefined;
+      blocking?: boolean | undefined;
+      matcher?: string | undefined;
+      env?: Record<string, {
+        kind: "secret-ref";
+        key: string;
+        format?: "raw" | "bearer" | undefined;
+      } | {
+        kind: "public";
+        value: string;
+      }> | undefined;
+    }[]>, unknown>>>;
+    modes: z.ZodOptional<z.ZodType<Record<string, {
+      description?: string | undefined;
+      model?: string | undefined;
+      prompt?: string | undefined;
+      tools?: Record<string, boolean> | undefined;
+      permissions?: Record<string, "allow" | "ask" | "deny" | Record<string, "allow" | "ask" | "deny">> | undefined;
+      metadata?: Record<string, unknown> | undefined;
+    }>, unknown, z.core.$ZodTypeInternals<Record<string, {
+      description?: string | undefined;
+      model?: string | undefined;
+      prompt?: string | undefined;
+      tools?: Record<string, boolean> | undefined;
+      permissions?: Record<string, "allow" | "ask" | "deny" | Record<string, "allow" | "ask" | "deny">> | undefined;
+      metadata?: Record<string, unknown> | undefined;
+    }>, unknown>>>;
+    confidential: z.ZodOptional<z.ZodObject<{
+      tee: z.ZodOptional<z.ZodString>;
+      attestationNonce: z.ZodOptional<z.ZodString>;
+      sealed: z.ZodOptional<z.ZodBoolean>;
+      attestationRefresh: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    metadata: z.ZodOptional<z.ZodType<_$_tangle_network_agent_interface0.AgentProfileMetadata, unknown, z.core.$ZodTypeInternals<_$_tangle_network_agent_interface0.AgentProfileMetadata, unknown>>>;
+    extensions: z.ZodOptional<z.ZodType<Record<string, Record<string, unknown> | undefined>, unknown, z.core.$ZodTypeInternals<Record<string, Record<string, unknown> | undefined>, unknown>>>;
+  }, z.core.$strict>;
+} extends infer T ? { -readonly [P in keyof T]: T[P] } : never, z.core.$strict>, z.ZodObject<Shape & {
+  profileSha256: z.ZodString;
+} extends infer T_1 ? { -readonly [P_1 in keyof T_1]: T_1[P_1] } : never, z.core.$strict>, z.ZodObject<{ -readonly [P_2 in keyof Shape]: Shape[P_2] }, z.core.$strict>]>;
+declare const agentRunWorkspaceSchema: z.ZodObject<{
+  rootPath: z.ZodOptional<z.ZodString>;
+  debugDirectory: z.ZodOptional<z.ZodString>;
+  skipInitialization: z.ZodOptional<z.ZodBoolean>;
+  cleanupOnShutdown: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+/** The shared request fields, in wire order around each end's workspace and backend. */
+declare function agentRunRequestSharedShape<Workspace extends z.ZodType, Backend extends z.ZodType>(workspace: Workspace, backend: Backend): {
+  sessionId: z.ZodOptional<z.ZodString>;
+  displayName: z.ZodOptional<z.ZodString>;
+  description: z.ZodOptional<z.ZodString>;
+  domains: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  workspace: Workspace;
+  backend: Backend;
+  expectedPublicProfileRequestDigest: z.ZodOptional<z.ZodString>;
+  expectedSecretProfileReceipt: z.ZodOptional<z.ZodString>;
+  githubToken: z.ZodOptional<z.ZodString>;
+  metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+};
+//#endregion
+//#region src/harness-contracts/contract.d.ts
+type HarnessBackendId = BackendType;
+type KeySource = "managed" | "api-key" | "api-key-env" | "cli-auth";
+/** A defect is evidence of missing proof, never a passing scenario. */
+interface HarnessDefect {
+  issue: string;
+  reason: string;
+}
+type SessionContract = {
+  kind: "native";
+  contract: HarnessSessionContract; /** Observe the installed CLI; pending defects still prevent recovery claims. */
+  processProbe: {
+    versionCommand: string; /** pgrep selector and expression, scoped to the fixture-owned sandbox. */
+    kill: readonly [string, string];
+  };
+  defect: HarnessDefect | null;
+} | {
+  kind: "unsupported";
+  defect: HarnessDefect;
+} | {
+  kind: "no-agent";
+  reason: string;
+};
+/** Serializable requirements; production policy and validators retain their owners. */
+type HarnessConfigAssertion = "managed-full-ladder" | "operator-model-first" | "named-model-exact" | "moonshot-provider-lock" | "responses-config-model-id";
+type HarnessConfigContract = {
+  kind: "model";
+  providerRequiresModel: true;
+  assertions?: readonly HarnessConfigAssertion[];
+  keySources: readonly [KeySource, ...KeySource[]];
+  baseUrl: "caller-or-managed" | "vendor-only";
+  envVars: CliAgentEnvVars;
+  modelWire: CliAgentModelWire;
+} | {
+  kind: "no-agent";
+  envVars: CliAgentEnvVars;
+  reason: string;
+};
+type LifecycleCapability = {
+  kind: "required";
+} | {
+  kind: "unsupported";
+  reason: string;
+};
+interface HarnessLifecycleContract {
+  /** Runtime consumers and probes read the same capability declaration. */
+  runtime: CliAgentRuntimeSpec | undefined;
+  coldCreate: LifecycleCapability;
+  warmClaim: LifecycleCapability;
+  parkResume: LifecycleCapability;
+  branchChild: LifecycleCapability;
+  killResume: LifecycleCapability;
+}
+interface HarnessContract {
+  session: SessionContract;
+  config: HarnessConfigContract;
+  lifecycle: HarnessLifecycleContract;
+}
+//#endregion
+//#region src/harness-contracts/index.d.ts
+declare const HARNESSES: {
+  "claude-code": {
+    session: {
+      kind: "native";
+      processProbe: {
+        versionCommand: string;
+        kill: [string, string];
+      };
+      contract: {
+        version: 1;
+        stores: [NativeSessionStore];
+        identity: {
+          kind: "pre-minted";
+          args: string[];
+        };
+        resume: {
+          kind: "args";
+          args: string[];
+        };
+        forbiddenArgs: string[];
+        storeEnv: {
+          CLAUDE_CONFIG_DIR: string;
+        };
+        evidence: {
+          servedModel: "provider-response";
+          usage: "per-response";
+          endingError: "session-record";
+        };
+        cliVersion: "2.1.311";
+      };
+      defect: null;
+    };
+    config: {
+      kind: "model";
+      providerRequiresModel: true;
+      assertions: ("managed-full-ladder" | "operator-model-first" | "named-model-exact")[];
+      keySources: ["managed", "api-key", "api-key-env", "cli-auth"];
+      baseUrl: "caller-or-managed";
+      modelWire: "anthropic-messages";
+      envVars: {
+        apiKey: string;
+        model: string;
+        authMode: string;
+        authFiles: string;
+        oauthToken: string;
+        baseUrl: string;
+      };
+    };
+    lifecycle: {
+      runtime: {};
+      coldCreate: {
+        kind: "required";
+      };
+      warmClaim: {
+        kind: "required";
+      };
+      parkResume: {
+        kind: "required";
+      };
+      branchChild: {
+        kind: "required";
+      };
+      killResume: {
+        kind: "required";
+      };
+    };
+  };
+  codex: {
+    session: {
+      kind: "native";
+      processProbe: {
+        versionCommand: string;
+        kill: [string, string];
+      };
+      contract: {
+        version: 1;
+        stores: [NativeSessionStore, NativeSessionStore];
+        identity: {
+          kind: "first-event";
+          event: string;
+          deadlineMs: number;
+        };
+        resume: {
+          kind: "args";
+          args: string[];
+        };
+        forbiddenArgs: string[];
+        storeEnv: {
+          CODEX_HOME: string;
+        };
+        evidence: {
+          servedModel: "turn-context";
+          usage: "cumulative";
+          endingError: "session-record";
+        };
+        cliVersion: "0.164.0";
+      };
+      defect: null;
+    };
+    config: {
+      kind: "model";
+      providerRequiresModel: true;
+      assertions: ("managed-full-ladder" | "operator-model-first" | "named-model-exact" | "responses-config-model-id")[];
+      keySources: ["managed", "api-key", "api-key-env", "cli-auth"];
+      baseUrl: "caller-or-managed";
+      modelWire: "openai-responses";
+      envVars: {
+        apiKey: string;
+        model: string;
+        authMode: string;
+        authFiles: string;
+        baseUrl: string;
+      };
+    };
+    lifecycle: {
+      runtime: undefined;
+      coldCreate: {
+        kind: "required";
+      };
+      warmClaim: {
+        kind: "required";
+      };
+      parkResume: {
+        kind: "required";
+      };
+      branchChild: {
+        kind: "required";
+      };
+      killResume: {
+        kind: "required";
+      };
+    };
+  };
+  opencode: {
+    session: {
+      kind: "native";
+      processProbe: {
+        versionCommand: string;
+        kill: [string, string];
+      };
+      contract: {
+        version: 1;
+        stores: [{
+          root: string;
+          files: string[];
+          write: "sqlite-wal";
+          shared: true;
+          format: "opencode.sqlite";
+        }];
+        identity: {
+          kind: "first-event";
+          event: string;
+          deadlineMs: number;
+        };
+        resume: {
+          kind: "args";
+          args: string[];
+        };
+        forbiddenArgs: never[];
+        storeEnv: {
+          XDG_DATA_HOME: string;
+        };
+        evidence: {
+          servedModel: "turn-context";
+          usage: "per-response";
+          endingError: "session-record";
+        };
+        cliVersion: "1.19.4";
+      };
+      defect: null;
+    };
+    config: {
+      kind: "model";
+      providerRequiresModel: true;
+      keySources: ["managed", "api-key", "api-key-env"];
+      baseUrl: "caller-or-managed";
+      modelWire: "openai-compat";
+      envVars: {
+        apiKey: string;
+        model: string;
+        baseUrl: string;
+        extras: {
+          OPENCODE_MODEL_PROVIDER: {
+            parser: "string";
+            role: "provider";
+          };
+          OPENCODE_MODEL_MODE: {
+            parser: "string";
+            role: "mode";
+          };
+        };
+      };
+    };
+    lifecycle: {
+      runtime: {
+        redactsHostEnv: true;
+        supportsToolDisabledTurns: true;
+      };
+      coldCreate: {
+        kind: "required";
+      };
+      warmClaim: {
+        kind: "required";
+      };
+      parkResume: {
+        kind: "required";
+      };
+      branchChild: {
+        kind: "required";
+      };
+      killResume: {
+        kind: "required";
+      };
+    };
+  };
+  pi: {
+    session: {
+      kind: "native";
+      processProbe: {
+        versionCommand: string;
+        kill: [string, string];
+      };
+      contract: {
+        version: 1;
+        stores: [{
+          root: string;
+          files: string[];
+          write: "jsonl-append";
+          shared: false;
+          format: "pi.session-jsonl";
+        }];
+        identity: {
+          kind: "pre-minted";
+          args: string[];
+        };
+        resume: {
+          kind: "args";
+          args: string[];
+        };
+        forbiddenArgs: string[];
+        storeEnv: {
+          PI_CODING_AGENT_DIR: string;
+          PI_CODING_AGENT_SESSION_DIR: string;
+          "--session-dir": string;
+        };
+        evidence: {
+          servedModel: "session-record";
+          usage: "per-response";
+          endingError: "session-record";
+        };
+        cliVersion: "1.4.0";
+      };
+      defect: null;
+    };
+    config: {
+      kind: "model";
+      providerRequiresModel: true;
+      keySources: ["managed", "api-key", "api-key-env", "cli-auth"];
+      baseUrl: "caller-or-managed";
+      modelWire: "openai-compat";
+      envVars: {
+        apiKey: string;
+        model: string;
+        baseUrl: string;
+      };
+    };
+    lifecycle: {
+      runtime: {};
+      coldCreate: {
+        kind: "required";
+      };
+      warmClaim: {
+        kind: "required";
+      };
+      parkResume: {
+        kind: "required";
+      };
+      branchChild: {
+        kind: "required";
+      };
+      killResume: {
+        kind: "required";
+      };
+    };
+  };
+  "kimi-code": {
+    session: {
+      kind: "native";
+      processProbe: {
+        versionCommand: string;
+        kill: [string, string];
+      };
+      contract: {
+        version: 1;
+        stores: [NativeSessionStore];
+        identity: {
+          kind: "pre-minted";
+          args: string[];
+        };
+        resume: {
+          kind: "args";
+          args: string[];
+        };
+        forbiddenArgs: never[];
+        storeEnv: {};
+        evidence: {
+          servedModel: "session-record";
+          usage: "per-response";
+          endingError: "none";
+        };
+        cliVersion: "1.49.0";
+      };
+      defect: {
+        issue: string;
+        reason: string;
+      };
+    };
+    config: {
+      kind: "model";
+      providerRequiresModel: true;
+      assertions: "moonshot-provider-lock"[];
+      keySources: ["managed", "api-key", "api-key-env", "cli-auth"];
+      baseUrl: "caller-or-managed";
+      modelWire: "openai-compat";
+      envVars: {
+        apiKey: string;
+        model: string;
+        authMode: string;
+        authFiles: string;
+        extras: {
+          OPENAI_BASE_URL: {
+            parser: "string";
+          };
+        };
+      };
+    };
+    lifecycle: {
+      runtime: {
+        warmRetention: {
+          envVar: string;
+          enabledByDefault: false;
+        };
+      };
+      coldCreate: {
+        kind: "required";
+      };
+      warmClaim: {
+        kind: "required";
+      };
+      parkResume: {
+        kind: "required";
+      };
+      branchChild: {
+        kind: "required";
+      };
+      killResume: {
+        kind: "required";
+      };
+    };
+  };
+  "factory-droids": {
+    session: {
+      kind: "native";
+      processProbe: {
+        versionCommand: string;
+        kill: [string, string];
+      };
+      contract: {
+        version: 1;
+        stores: [{
+          root: string;
+          files: string[];
+          write: "jsonl-append";
+          shared: false;
+          format: "factory.session-jsonl";
+        }, {
+          root: string;
+          files: string[];
+          write: "json-rewrite";
+          shared: false;
+          format: "factory.session-jsonl";
+        }];
+        identity: {
+          kind: "first-event";
+          event: string;
+          deadlineMs: number;
+        };
+        resume: {
+          kind: "args";
+          args: string[];
+        };
+        forbiddenArgs: never[];
+        storeEnv: {};
+        evidence: {
+          servedModel: "turn-context";
+          usage: "session-total";
+          endingError: "none";
+        };
+        cliVersion: "0.249.0";
+      };
+      defect: {
+        issue: string;
+        reason: string;
+      };
+    };
+    config: {
+      kind: "model";
+      providerRequiresModel: true;
+      keySources: ["managed", "api-key", "api-key-env"];
+      baseUrl: "caller-or-managed";
+      modelWire: "openai-compat";
+      envVars: {
+        apiKey: string;
+        model: string;
+      };
+    };
+    lifecycle: {
+      runtime: undefined;
+      coldCreate: {
+        kind: "required";
+      };
+      warmClaim: {
+        kind: "required";
+      };
+      parkResume: {
+        kind: "required";
+      };
+      branchChild: {
+        kind: "required";
+      };
+      killResume: {
+        kind: "required";
+      };
+    };
+  };
+  amp: {
+    session: {
+      kind: "native";
+      processProbe: {
+        versionCommand: string;
+        kill: [string, string];
+      };
+      contract: {
+        version: 1;
+        stores: [{
+          root: string;
+          files: string[];
+          write: "json-rewrite";
+          shared: false;
+          format: "amp.thread-json";
+        }];
+        identity: {
+          kind: "first-event";
+          event: string;
+          deadlineMs: number;
+        };
+        resume: {
+          kind: "args";
+          args: string[];
+        };
+        forbiddenArgs: never[];
+        storeEnv: {
+          XDG_DATA_HOME: string;
+        };
+        evidence: {
+          servedModel: "session-record";
+          usage: "per-response";
+          endingError: "none";
+        };
+        cliVersion: "0.0.1793044831-ga1b1a0";
+      };
+      defect: {
+        issue: string;
+        reason: string;
+      };
+    };
+    config: {
+      kind: "model";
+      providerRequiresModel: true;
+      keySources: ["api-key", "api-key-env", "cli-auth"];
+      baseUrl: "vendor-only";
+      modelWire: "openai-compat";
+      envVars: {
+        apiKey: string;
+        model: string;
+        authMode: string;
+        authFiles: string;
+      };
+    };
+    lifecycle: {
+      runtime: undefined;
+      coldCreate: {
+        kind: "required";
+      };
+      warmClaim: {
+        kind: "required";
+      };
+      parkResume: {
+        kind: "required";
+      };
+      branchChild: {
+        kind: "required";
+      };
+      killResume: {
+        kind: "required";
+      };
+    };
+  };
+  prime: {
+    session: {
+      kind: "native";
+      processProbe: {
+        versionCommand: string;
+        kill: [string, string];
+      };
+      contract: {
+        version: 1;
+        stores: [{
+          root: string;
+          files: string[];
+          write: "jsonl-append";
+          shared: false;
+          format: "prime.session-jsonl";
+        }];
+        identity: {
+          kind: "api-created";
+          call: "acp session/new";
+        };
+        resume: {
+          kind: "api";
+        };
+        forbiddenArgs: string[];
+        storeEnv: {};
+        evidence: {
+          servedModel: "session-record";
+          usage: "per-response";
+          endingError: "session-record";
+        };
+        cliVersion: "0.10.1";
+      };
+      defect: {
+        issue: string;
+        reason: string;
+      };
+    };
+    config: {
+      kind: "model";
+      providerRequiresModel: true;
+      keySources: ["managed", "api-key", "api-key-env"];
+      baseUrl: "caller-or-managed";
+      modelWire: "openai-compat";
+      envVars: {
+        apiKey: string;
+        model: string;
+        baseUrl: string;
+      };
+    };
+    lifecycle: {
+      runtime: undefined;
+      coldCreate: {
+        kind: "required";
+      };
+      warmClaim: {
+        kind: "required";
+      };
+      parkResume: {
+        kind: "required";
+      };
+      branchChild: {
+        kind: "required";
+      };
+      killResume: {
+        kind: "required";
+      };
+    };
+  };
+  hermes: {
+    session: {
+      kind: "native";
+      processProbe: {
+        versionCommand: string;
+        kill: [string, string];
+      };
+      contract: {
+        version: 1;
+        stores: [NativeSessionStore];
+        identity: {
+          kind: "first-event";
+          event: string;
+          deadlineMs: number;
+        };
+        resume: {
+          kind: "args";
+          args: string[];
+        };
+        forbiddenArgs: never[];
+        storeEnv: {
+          HERMES_HOME: string;
+        };
+        evidence: {
+          servedModel: "session-record";
+          usage: "session-total";
+          endingError: "none";
+        };
+        cliVersion: "0.22.4";
+      };
+      defect: {
+        issue: string;
+        reason: string;
+      };
+    };
+    config: {
+      kind: "model";
+      providerRequiresModel: true;
+      keySources: ["managed", "api-key", "api-key-env", "cli-auth"];
+      baseUrl: "caller-or-managed";
+      modelWire: "openai-compat";
+      envVars: {
+        apiKey: string;
+        model: string;
+        authMode: string;
+        authFiles: string;
+        baseUrl: string;
+        extras: {
+          HERMES_INFERENCE_PROVIDER: {
+            parser: "string";
+          };
+        };
+      };
+    };
+    lifecycle: {
+      runtime: undefined;
+      coldCreate: {
+        kind: "required";
+      };
+      warmClaim: {
+        kind: "required";
+      };
+      parkResume: {
+        kind: "required";
+      };
+      branchChild: {
+        kind: "required";
+      };
+      killResume: {
+        kind: "required";
+      };
+    };
+  };
+  forge: {
+    session: {
+      kind: "native";
+      processProbe: {
+        versionCommand: string;
+        kill: [string, string];
+      };
+      contract: {
+        version: 1;
+        stores: [{
+          root: string;
+          files: string[];
+          write: "sqlite-wal";
+          shared: true;
+          format: "forge.sqlite";
+        }];
+        identity: {
+          kind: "first-event";
+          event: string;
+          deadlineMs: number;
+        };
+        resume: {
+          kind: "args";
+          args: string[];
+        };
+        forbiddenArgs: never[];
+        storeEnv: {};
+        evidence: {
+          servedModel: "session-record";
+          usage: "per-response";
+          endingError: "none";
+        };
+        cliVersion: "2.14.0";
+      };
+      defect: {
+        issue: string;
+        reason: string;
+      };
+    };
+    config: {
+      kind: "model";
+      providerRequiresModel: true;
+      keySources: ["managed", "api-key", "api-key-env", "cli-auth"];
+      baseUrl: "caller-or-managed";
+      modelWire: "openai-compat";
+      envVars: {
+        apiKey: string;
+        model: string;
+        authMode: string;
+        authFiles: string;
+        extras: {
+          FORGE_SESSION__PROVIDER_ID: {
+            parser: "string";
+          };
+          FORGE_SESSION__MODEL_ID: {
+            parser: "string";
+          };
+          FORGE_AGENT_ID: {
+            parser: "string";
+          };
+        };
+      };
+    };
+    lifecycle: {
+      runtime: undefined;
+      coldCreate: {
+        kind: "required";
+      };
+      warmClaim: {
+        kind: "required";
+      };
+      parkResume: {
+        kind: "required";
+      };
+      branchChild: {
+        kind: "required";
+      };
+      killResume: {
+        kind: "required";
+      };
+    };
+  };
+  openclaw: {
+    session: {
+      kind: "native";
+      processProbe: {
+        versionCommand: string;
+        kill: [string, string];
+      };
+      contract: {
+        version: 1;
+        stores: [{
+          root: string;
+          files: string[];
+          write: "jsonl-append";
+          shared: false;
+          format: "openclaw.session-jsonl";
+        }];
+        identity: {
+          kind: "first-event";
+          event: string;
+          deadlineMs: number;
+        };
+        resume: {
+          kind: "args";
+          args: string[];
+        };
+        forbiddenArgs: never[];
+        storeEnv: {};
+        evidence: {
+          servedModel: "session-record";
+          usage: "per-response";
+          endingError: "none";
+        };
+        cliVersion: "2026.10.7";
+      };
+      defect: {
+        issue: string;
+        reason: string;
+      };
+    };
+    config: {
+      kind: "model";
+      providerRequiresModel: true;
+      keySources: ["managed", "api-key", "api-key-env", "cli-auth"];
+      baseUrl: "caller-or-managed";
+      modelWire: "openai-compat";
+      envVars: {
+        apiKey: string;
+        model: string;
+        baseUrl: string;
+        authMode: string;
+        authFiles: string;
+      };
+    };
+    lifecycle: {
+      runtime: undefined;
+      coldCreate: {
+        kind: "required";
+      };
+      warmClaim: {
+        kind: "required";
+      };
+      parkResume: {
+        kind: "required";
+      };
+      branchChild: {
+        kind: "required";
+      };
+      killResume: {
+        kind: "required";
+      };
+    };
+  };
+  nanoclaw: {
+    session: {
+      kind: "unsupported";
+      defect: {
+        issue: string;
+        reason: string;
+      };
+    };
+    config: {
+      kind: "model";
+      providerRequiresModel: true;
+      keySources: ["managed", "api-key", "api-key-env"];
+      baseUrl: "caller-or-managed";
+      modelWire: "openai-compat";
+      envVars: {
+        apiKey: string;
+        model: string;
+        authMode: string;
+        baseUrl: string;
+        extras: {
+          NANOCLAW_PROJECT_ROOT: {
+            parser: "string";
+          };
+          NANOCLAW_NATIVE_CREDENTIALS: {
+            parser: "string";
+          };
+          OPENCODE_MODEL_PROVIDER: {
+            parser: "string";
+            role: "provider";
+          };
+        };
+      };
+    };
+    lifecycle: {
+      runtime: undefined;
+      coldCreate: {
+        kind: "required";
+      };
+      warmClaim: {
+        kind: "required";
+      };
+      parkResume: {
+        kind: "required";
+      };
+      branchChild: {
+        kind: "required";
+      };
+      killResume: {
+        kind: "unsupported";
+        reason: string;
+      };
+    };
+  };
+  acp: {
+    session: {
+      kind: "native";
+      processProbe: {
+        versionCommand: string;
+        kill: [string, string];
+      };
+      contract: {
+        version: 1;
+        stores: [NativeSessionStore, NativeSessionStore, NativeSessionStore, NativeSessionStore, NativeSessionStore];
+        identity: {
+          kind: "api-created";
+          call: "acp session/new";
+        };
+        resume: {
+          kind: "api";
+        };
+        forbiddenArgs: never[];
+        storeEnv: {};
+        evidence: {
+          servedModel: "session-record";
+          usage: "per-response";
+          endingError: "none";
+        };
+        cliVersion: "claude-agent-acp 0.97.0; codex-acp 0.16.0; gemini-cli 0.65.0";
+      };
+      defect: {
+        issue: string;
+        reason: string;
+      };
+    };
+    config: {
+      kind: "model";
+      providerRequiresModel: true;
+      keySources: ["managed", "api-key", "api-key-env", "cli-auth"];
+      baseUrl: "caller-or-managed";
+      modelWire: "openai-compat";
+      envVars: {
+        apiKey: string;
+        model: string;
+        baseUrl: string;
+        authFiles: string;
+      };
+    };
+    lifecycle: {
+      runtime: undefined;
+      coldCreate: {
+        kind: "required";
+      };
+      warmClaim: {
+        kind: "required";
+      };
+      parkResume: {
+        kind: "required";
+      };
+      branchChild: {
+        kind: "required";
+      };
+      killResume: {
+        kind: "required";
+      };
+    };
+  };
+  cursor: {
+    session: {
+      kind: "unsupported";
+      defect: {
+        issue: string;
+        reason: string;
+      };
+    };
+    config: {
+      kind: "model";
+      providerRequiresModel: true;
+      keySources: ["api-key", "api-key-env"];
+      baseUrl: "vendor-only";
+      modelWire: "openai-compat";
+      envVars: {
+        apiKey: string;
+        model: string;
+      };
+    };
+    lifecycle: {
+      runtime: undefined;
+      coldCreate: {
+        kind: "required";
+      };
+      warmClaim: {
+        kind: "required";
+      };
+      parkResume: {
+        kind: "required";
+      };
+      branchChild: {
+        kind: "required";
+      };
+      killResume: {
+        kind: "unsupported";
+        reason: string;
+      };
+    };
+  };
+  "cli-base": {
+    session: {
+      kind: "no-agent";
+      reason: string;
+    };
+    config: {
+      kind: "no-agent";
+      envVars: {};
+      reason: string;
+    };
+    lifecycle: {
+      runtime: undefined;
+      coldCreate: {
+        kind: "unsupported";
+        reason: string;
+      };
+      warmClaim: {
+        kind: "unsupported";
+        reason: string;
+      };
+      parkResume: {
+        kind: "unsupported";
+        reason: string;
+      };
+      branchChild: {
+        kind: "unsupported";
+        reason: string;
+      };
+      killResume: {
+        kind: "unsupported";
+        reason: string;
+      };
+    };
+  };
+};
+//#endregion
+export { AGENT_BACKEND_ENV_VAR, ALL_BACKEND_TYPES, type AdapterFactory, type AdapterRegistry, type AgentRunBackend, BACKEND_TYPE, type BackendType, CLI_AGENT_SPECS, type CliAgentBuiltinTool, type CliAgentEnvExtra, type CliAgentEnvExtraParser, type CliAgentEnvExtraRole, type CliAgentEnvVars, type CliAgentModelWire, type CliAgentRuntimeSpec, type CliAgentSpec, type CliAuthHome, type CliDirLayout, type CliDirLayoutAdditions, DEFAULT_CLI_DIR_LAYOUT, HARNESSES, HARNESS_CONFORMANCE_PENDING, HARNESS_SESSION_UNSUPPORTED, type HarnessBackendId, type HarnessContract, HarnessSessionContract, HarnessSessionContractError, HarnessSessionContractErrorCode, HarnessSessionEvidence, type HarnessSpecCapabilities, type LocalCliAuthFile, MANAGED_MODEL_KEY_ENV_VAR, MANAGED_MODEL_KEY_NAME_ENV_VAR, MANAGED_MODEL_LADDER, type ManagedModelChain, type ManagedModelChainOptions, type ManagedModelRung, NATIVE_SESSION_CONTRACTS, NativeSessionIdentity, NativeSessionStore, type ProviderLogger, type ProviderPhase, SESSION_FORMAT_IDS, SYNTHETIC_ROUTER_MODEL, SessionFormatId, type SkippedManagedModel, agentProfileSchema, agentRunBackendVariants, agentRunRequestSharedShape, agentRunWorkspaceSchema, assertAdaptersWired, assertArgvHonoursSessionContract, assertFlagsHonourSessionContract, assertStoreLocationHonoursSessionContract, backendTypeSchema, bareModelId, canonicalModelSlug, claimDeliverableEnvVarNames, cliAgentClaimEnvVarNames, cliAgentEnvRoleName, cliAgentEnvVarNamesByRole, cliAgentHostPassthroughEnvVarNames, compileSessionStoreGlob, configDirHomeEnv, createAdapterRegistry, describeLocalCliAuthExpectation, discoverLocalCliAuthFiles, forbiddenArgViolations, getAdapterFactory, getSpec, harnessModelSupportFor, harnessModelWire, isBackendType, isServableManagedModel, listRegisteredAdapters, managedModelChain, materializeCliAuthBundle, mergeCliDirLayout, messageStorageDirOf, normalizePosixPath, parseBackendType, registerAdapterFactory, resolveDefaultBackend, sessionContractProblems, sessionStoreForPath, substituteNativeSessionId, unregisterAdapterFactory };
+//# sourceMappingURL=index.d.mts.map