@claxedo/agent-runtime-contract 0.8.0 → 0.10.0

package/dist/recovery/requests.d.ts

@@ -0,0 +1,44 @@
+import { type RecoveryAction } from "./actions";
+import { type RecoveryTarget } from "./targets";
+/**
+ * The drain a `release_drain` reopens, by operation id.
+ *
+ * Releasing is always about one earlier operation's gates, never about "the
+ * fence" in general: two drains can hold overlapping owners, and reopening
+ * whatever happens to be closed would un-gate a scope its own caller never
+ * authorized reopening. The id rides in `linkedOperationId`, which is the field
+ * for exactly this — a request that names another operation — so a release
+ * without one is refused before it reaches an owner.
+ */
+export declare function releasedDrainOperationId(request: RecoveryRequest): string | undefined;
+export type RecoveryRequest = {
+    /** Unique per caller, not globally: two callers may reuse the same string. */
+    requestId: string;
+    action: RecoveryAction;
+    target: RecoveryTarget;
+    /** The revision of the impact scope the caller was shown and authorized. */
+    scopeRevision: string;
+    attempt: number;
+    /** The failed operation an explicit retry, or a nested child, is linked to. */
+    linkedOperationId?: string;
+};
+/**
+ * The part of a request that decides whether a second delivery of the same
+ * request id is the same command. Attempt and request id are excluded: a retry
+ * is a new attempt of one intent, and the id is the key being compared under.
+ */
+export type RecoveryIntent = {
+    action: RecoveryAction;
+    scopeRevision: string;
+    target: RecoveryTarget;
+    linkedOperationId?: string;
+};
+/**
+ * Key order comes from the literals here rather than from the caller's object,
+ * so `JSON.stringify` of the result is canonical and can be stored as the
+ * column an owner compares a repeated request id against.
+ */
+export declare function normalizeRecoveryIntent(request: RecoveryRequest): RecoveryIntent;
+/** Repeated deliveries must compare canonical intent rather than caller-supplied key order. */
+export declare function recoveryIntentEquals(a: RecoveryRequest, b: RecoveryRequest): boolean;
+export declare function parseRecoveryRequest(input: unknown): RecoveryRequest;

package/dist/recovery/targets.d.ts

@@ -0,0 +1,55 @@
+import { type RecoveryGeneration } from "./facts";
+export declare const RECOVERY_TARGET_SCOPES: readonly ["turn", "session", "harness", "machine"];
+export type RecoveryTargetScope = (typeof RECOVERY_TARGET_SCOPES)[number];
+export type RecoveryTurnTarget = {
+    scope: "turn";
+    machineId?: string;
+    workspaceId: string;
+    sessionId: string;
+    turnId: string;
+    ownerGeneration: RecoveryGeneration;
+    /** The durable lease or token id whose holder may write for this target. */
+    writeAuthority?: string;
+};
+export type RecoverySessionTarget = {
+    scope: "session";
+    machineId?: string;
+    workspaceId: string;
+    sessionId: string;
+    ownerGeneration: RecoveryGeneration;
+};
+export type RecoveryHarnessTarget = {
+    scope: "harness";
+    machineId?: string;
+    workspaceId: string;
+    /** The harness generation's own key; a harness may serve several sessions. */
+    harnessKey: string;
+    ownerGeneration: RecoveryGeneration;
+};
+export type RecoveryMachineTarget = {
+    scope: "machine";
+    machineId: string;
+    ownerGeneration: RecoveryGeneration;
+};
+/**
+ * The scopes carry different fields because they name different things: a
+ * daemon has no session and a harness generation outlives any one turn.
+ * Flattening them would make a caller invent a session id to drain a daemon,
+ * and an invented identity is indistinguishable from a real one downstream.
+ */
+export type RecoveryTarget = RecoveryTurnTarget | RecoverySessionTarget | RecoveryHarnessTarget | RecoveryMachineTarget;
+export declare function normalizeRecoveryTarget(target: RecoveryTarget): RecoveryTarget;
+/**
+ * Whether two targets name the same resource under the same owner generation.
+ * `writeAuthority` is excluded: a lease may be renewed or reissued for the very
+ * turn a caller is checking, so comparing it would call a live target stale.
+ */
+export declare function recoveryTargetsMatch(a: RecoveryTarget, b: RecoveryTarget): boolean;
+export declare function parseRecoveryTarget(input: unknown): RecoveryTarget;
+/**
+ * The row a repeated recovery request is compared under. A turn operation and a
+ * session operation share their session's key, so a caller cannot escape its
+ * own uniqueness by naming a different turn of the same session.
+ */
+export declare function recoveryScopeKey(target: RecoveryTarget): string;
+export declare function recoveryTargetSessionId(target: RecoveryTarget): string | null;

package/dist/recovery/validation.d.ts

@@ -0,0 +1,9 @@
+export declare const RECOVERY_CONTRACT_ERROR_CODES: readonly ["invalid_payload", "invalid_request_id", "invalid_action", "invalid_attempt", "invalid_scope_revision", "invalid_target", "invalid_target_scope", "scope_mismatch", "missing_generation", "invalid_observed_at", "invalid_fact", "invalid_operation", "invalid_refusal", "invalid_budget"];
+export type RecoveryContractErrorCode = (typeof RECOVERY_CONTRACT_ERROR_CODES)[number];
+export declare class RecoveryContractError extends Error {
+    readonly code: RecoveryContractErrorCode;
+    constructor(code: RecoveryContractErrorCode, message: string);
+}
+export declare function member<T extends string>(values: readonly T[], value: unknown): value is T;
+export declare function requireRecoveryText(value: unknown, code: RecoveryContractErrorCode, label: string): string;
+export declare function requireRecoveryNumber(value: unknown, code: RecoveryContractErrorCode, label: string): number;

package/dist/runtime-content.d.ts

@@ -0,0 +1,34 @@
+export type RuntimeContentBlock = {
+    type: "text";
+    text: string;
+} | {
+    type: "image";
+    data: string;
+    mimeType: string;
+    uri?: string | null;
+} | {
+    type: "audio";
+    data: string;
+    mimeType: string;
+} | {
+    type: "resource_link";
+    uri: string;
+    name: string;
+    mimeType?: string | null;
+    title?: string | null;
+} | {
+    type: "resource";
+    resource: unknown;
+};
+export type RuntimeToolCallContent = {
+    type: "content";
+    content: RuntimeContentBlock;
+} | {
+    type: "diff";
+    path: string;
+    oldText?: string | null;
+    newText: string;
+} | {
+    type: "terminal";
+    terminalId: string;
+};

package/dist/session-handoff.d.ts

@@ -0,0 +1,4 @@
+import type { AgentMessage } from "./content";
+import { type SessionHarness } from "./harnesses";
+export declare function renderSessionTranscript(rows: readonly AgentMessage[]): string;
+export declare function renderSessionHandoff(rows: readonly AgentMessage[], from: SessionHarness): string;

package/dist/session-titles.d.ts

@@ -0,0 +1,14 @@
+import type { PromptModel } from "./sessions";
+/**
+ * What a harness receives when the runtime asks it for a title: the shared
+ * instruction, the conversation excerpt, and the session's own model, so
+ * the side turn runs under the same credentials as the session.
+ */
+export type SessionTitleRequest = {
+    directory: string;
+    system: string;
+    user: string;
+    /** The session's selected model; absent when the session runs the harness default. */
+    model?: PromptModel;
+    signal: AbortSignal;
+};

package/dist/sessions.d.ts

@@ -1,5 +1,16 @@
+import type { SessionHarness } from "./harnesses";
+import type { SessionModelGroup } from "./session-group";
+import type { AutoLevel } from "./permissions";
+import type { CleanupFact, ExecutionFact } from "./recovery/facts";
+import type { RecoveryErrorCode } from "./recovery/operations";
 import type { ExecutionAvailability } from "./availability";
 import type { AgentAgentPartInput, AgentFilePartInput, AgentTextPartInput } from "./content";
+import type { FirstTurnErrorClass } from "./turn-error-classes";
+import type { TurnAccount } from "./turn-account";
+export type SessionRef = Readonly<{
+    sessionId: string;
+    workspaceId: string;
+}>;
 export type AgentWorkspaceIdentity = {
     workspaceId: string;
     directory: string;
@@ -9,13 +20,48 @@ export type AgentWorkspaceIdentity = {
  * `upstreamSessionId` is opaque: Claxedo stores and forwards it but never
  * parses it or uses it to discover sessions.
  */
-export type AgentWorkspaceExecutionBinding = AgentWorkspaceIdentity & {
+export type AgentWorkspaceExecutionBinding = AgentWorkspaceIdentity & SessionRef & {
     scope?: "workspace";
-    sessionId: string;
     connectionId: string;
     upstreamSessionId: string;
 };
 export type AgentExecutionBinding = AgentWorkspaceExecutionBinding;
+/** Ownership of creation before the provider has returned any session identity. */
+export type AgentSessionStartBinding = AgentWorkspaceIdentity & SessionRef & {
+    connectionId: string;
+    operationId: string;
+};
+export type AgentSessionStart = {
+    binding: AgentSessionStartBinding;
+    createdAt: number;
+    updatedAt: number;
+} & ({
+    status: "starting";
+} | {
+    status: "created";
+    upstreamSessionId: string;
+} | {
+    status: "failed";
+    error: string;
+});
+export interface AgentSessionStarts {
+    get(sessionId: string): AgentSessionStart | undefined;
+    begin(binding: AgentSessionStartBinding): AgentSessionStart;
+    finish(binding: AgentSessionStartBinding, outcome: {
+        status: "created";
+        upstreamSessionId: string;
+    } | {
+        status: "failed";
+        error: string;
+    }): AgentSessionStart;
+    /**
+     * Gives the id back after an authorized deletion has already removed the
+     * provider session. Every binding field must still match, so an operation
+     * that read the record before a newer one took the id cannot retire it.
+     * Answers whether this call removed the record.
+     */
+    retire(binding: AgentSessionStartBinding): boolean;
+}
 export type AgentExecutionBindingField = keyof AgentExecutionBinding;
 export type AgentExecutionBindingExpectation = Readonly<{
     scope?: "workspace";
@@ -25,10 +71,25 @@ export type AgentExecutionBindingExpectation = Readonly<{
     connectionId: string;
     upstreamSessionId: string;
 }>;
+/**
+ * Who wrote the current title, ranked: a user rename beats a harness or
+ * model-generated title, which beats the first-prompt placeholder. A writer of
+ * lower rank than the stored one is dropped by the store.
+ */
+export type AgentSessionTitleSource = "prompt" | "harness" | "user";
+/** Commands advertised by this agent session; invoked as slash-prefixed prompts. */
+export type AgentSessionCommand = {
+    name: string;
+    description: string;
+    input?: {
+        hint: string;
+    } | null;
+};
 export type AgentSession = {
     id: string;
     workspaceId?: string;
     title?: string | null;
+    titleSource?: AgentSessionTitleSource;
     slug?: string;
     version?: string;
     directory?: string;
@@ -47,6 +108,7 @@ export type AgentSession = {
     lastTurn?: AgentTurnOutcome;
     executionAvailability?: ExecutionAvailability;
     harnessPayload?: unknown;
+    commands?: AgentSessionCommand[];
 };
 export type AgentPresentationSession = AgentSession & {
     tags?: string[];
@@ -104,10 +166,15 @@ export type AgentTurnOutcome = ({
     status: "completed";
     completedAt: number;
     reason?: string;
-} | {
+}
+/** `detail` is what the harness's transport established about the failure, carried onto the turn's error record. */
+ | {
     status: "failed";
     completedAt: number;
     error: string;
+    errorClass?: FirstTurnErrorClass;
+    account?: TurnAccount;
+    detail?: Readonly<Record<string, string>>;
 } | {
     status: "cancelled";
     completedAt: number;
@@ -115,6 +182,8 @@ export type AgentTurnOutcome = ({
 }) & {
     assistantMessageId?: string;
 };
+/** A session's last turn as a session list row and a turn-end frame carry it: the two facts every store of it keeps. */
+export type SessionLastTurn = Pick<AgentTurnOutcome, "status" | "completedAt">;
 export type PromptModel = {
     providerID: string;
     modelID: string;
@@ -136,12 +205,17 @@ export type PromptInput = {
     /** Existing user intent that owns a provider-initiated continuation. */
     parentMessageId?: string;
     assistantMessageId: string;
-    agent: string;
-    model: PromptModel;
+    agent?: string;
+    model?: PromptModel;
     tools?: Record<string, boolean>;
     format?: PromptFormat;
     system?: string;
     variant?: string;
+    /**
+     * A faster tier the selected model advertises (Codex `priority`, "Fast").
+     * Absent runs the standard tier; a harness drops a tier the model lacks.
+     */
+    serviceTier?: string;
     permissionMode?: string;
     /**
      * What to do when the session is already running a turn. `steer` hands this
@@ -164,3 +238,107 @@ export declare function connectionIdForHarness(harness: {
     id: string;
     access: string;
 }): string;
+/**
+ * Conversation context owed to a session's fresh native thread, carried on
+ * every turn until one completes. `announced` records that the harness change
+ * was written onto a sent user message, so a retried first turn does not mark
+ * it again.
+ */
+export type SessionHandoff = {
+    from: SessionHarness;
+    pending: true;
+    transcript: string;
+    announced?: true;
+    source?: SessionHandoffSource;
+};
+/**
+ * The native session of the harness a handoff left, and the config it ran
+ * under. It is kept until a message is sent on the new harness, so picking the
+ * left harness back resumes its own thread instead of a transcript copy.
+ */
+export type SessionHandoffSource = {
+    agentSessionId: string;
+    upstreamSessionId: string;
+    ownerKey: string | null;
+    model?: PromptModel;
+    variant?: string | null;
+    agent?: string | null;
+    handoff?: Omit<SessionHandoff, "source">;
+};
+export type SessionConfig = {
+    /** Host-owned maximum permission level, retained across harness changes. */
+    permissionCeiling?: AutoLevel;
+    /** Accepted harness mode, persisted by the permission-mode operation. */
+    permissionMode?: string;
+    /**
+     * The accepted mode's name as the agent listed it when the mode was stored.
+     * Only a harness whose modes the runtime contract does not declare has one,
+     * so a client can name the mode without asking the agent for its list.
+     */
+    permissionModeLabel?: string;
+    /** Native permission state accepted by the driver; opaque to shared consumers. */
+    permissionState?: Record<string, unknown>;
+    harness: SessionHarness;
+    model?: PromptModel;
+    variant?: string | null;
+    agent?: string | null;
+    /**
+     * Standing instructions this session was created with. Retained so a session
+     * reopened after a restart keeps them without the caller resending anything;
+     * where they reach the harness is that harness's own `instructionChannel`,
+     * and one with none refuses the create rather than dropping them.
+     */
+    instructions?: string | null;
+    /**
+     * The resolved model group this session was created under, machine-readable
+     * so a later reader — a delegation request naming a slot, say — resolves the
+     * same harness/model/effort the creator chose instead of re-parsing the
+     * instruction prose the group was also rendered into.
+     */
+    group?: SessionModelGroup | null;
+    handoff?: SessionHandoff | null;
+};
+/**
+ * Partial update for a session config.
+ *
+ * - `undefined` leaves a field unchanged.
+ * - `null` clears optional nullable fields.
+ * - a value replaces the field.
+ *
+ * `harness` is a full replacement, not a deep merge.
+ */
+export type SessionConfigUpdate = {
+    permissionCeiling?: SessionConfig["permissionCeiling"];
+    permissionMode?: string | null;
+    permissionModeLabel?: string | null;
+    permissionState?: Record<string, unknown> | null;
+    harness?: SessionHarness;
+    model?: PromptModel | null;
+    variant?: string | null;
+    agent?: string | null;
+    instructions?: string | null;
+    group?: SessionModelGroup | null;
+    handoff?: SessionHandoff | null;
+};
+/**
+ * What an adapter observed while trying to stop a turn. Execution and cleanup
+ * are separate facts because acknowledging a cancel is not stopping, and an
+ * adapter that closed its own stream has not thereby released the provider's
+ * terminals or child processes. `unknown` is the answer whenever the adapter's
+ * protocol cannot tell those apart; the runtime keeps the turn owned on it.
+ */
+export type AdapterCancelOutcome = {
+    execution: ExecutionFact;
+    cleanup: CleanupFact;
+    error?: {
+        code: RecoveryErrorCode;
+        message: string;
+    };
+};
+export type SteerResult = {
+    ok: true;
+} | {
+    ok: false;
+    status: "no_active_turn" | "declined" | "unsupported" | "unknown";
+    message: string;
+};

package/dist/stream-heartbeat.d.ts

@@ -0,0 +1,11 @@
+/**
+ * How often every event stream writes a heartbeat frame: a workspace
+ * runtime's `wr/events`, the local daemon's `cp/events`, and the hosted
+ * `cp/events` whether it bridges a live-sync room or stands alone.
+ */
+export declare const EVENT_STREAM_HEARTBEAT_MS = 10000;
+/**
+ * How long a reader waits for any frame before it drops the stream: two
+ * missed heartbeats, plus one beat of jitter for the third to arrive.
+ */
+export declare const EVENT_STREAM_STALL_TIMEOUT_MS: number;

package/dist/subagents.d.ts

@@ -0,0 +1,92 @@
+export declare const RUNTIME_GOAL_STATUSES: readonly ["active", "paused", "blocked", "limited", "complete"];
+export type RuntimeGoalStatus = typeof RUNTIME_GOAL_STATUSES[number];
+export type RuntimeGoalSnapshot = {
+    /** Claxedo session identity. One session owns at most one Goal. */
+    sessionId: string;
+    objective: string;
+    status: RuntimeGoalStatus;
+    createdAt: number;
+    updatedAt: number;
+    /** Provider-reported fields. Absence means unknown and must remain absent. */
+    tokenBudget?: number;
+    tokensUsed?: number;
+    timeUsedSeconds?: number;
+    iteration?: number;
+    lastReason?: string;
+};
+export declare function isRuntimeGoalStatus(value: unknown): value is RuntimeGoalStatus;
+export declare const SUBAGENT_STATUSES: readonly ["pending", "running", "paused", "interrupted", "completed", "failed", "killed"];
+export type SubagentStatus = typeof SUBAGENT_STATUSES[number];
+export declare function isTerminalSubagentStatus(status: string | undefined): boolean;
+export declare const SUBAGENT_MODES: readonly ["foreground", "background"];
+export type SubagentMode = typeof SUBAGENT_MODES[number];
+export declare const SUBAGENT_TOOL_CALL_ROLES: readonly ["spawn", "interaction"];
+export type SubagentToolCallRole = typeof SUBAGENT_TOOL_CALL_ROLES[number];
+/**
+ * The completion wake a host-owned child owes its parent: `pending` until the
+ * runtime has started the parent turn that carries the child's summary.
+ */
+export declare const SUBAGENT_WAKES: readonly ["pending", "delivered"];
+export type SubagentWake = typeof SUBAGENT_WAKES[number];
+export declare const SUBAGENT_TRANSCRIPT_KINDS: readonly ["live", "file", "messages", "none"];
+export type SubagentTranscript = {
+    kind: typeof SUBAGENT_TRANSCRIPT_KINDS[number];
+    ref?: string;
+};
+export declare const isSubagentStatus: (value: unknown) => value is SubagentStatus;
+export declare const isSubagentMode: (value: unknown) => value is SubagentMode;
+export declare const isSubagentToolCallRole: (value: unknown) => value is SubagentToolCallRole;
+export declare const isSubagentWake: (value: unknown) => value is SubagentWake;
+export declare const isSubagentTranscriptKind: (value: unknown) => value is SubagentTranscript["kind"];
+/** One revision of a subagent row, as the runtime observed it. */
+export type AgentSubagentUpdate = {
+    subagentKey: string;
+    revision: number;
+    toolCallId?: string;
+    toolCallRole?: SubagentToolCallRole;
+    mode?: SubagentMode;
+    status?: SubagentStatus;
+    /** Revision at which the admission store verified the current run identity. */
+    runRevision?: number;
+    label?: string;
+    subagentType?: string;
+    description?: string;
+    providerId?: string;
+    providerKind?: string;
+    childSessionId?: string;
+    transcript?: SubagentTranscript;
+    /** Permission and question requests the child is holding open, to be answered by a human. */
+    attention?: number;
+    wake?: SubagentWake;
+};
+export type SubagentObservation = {
+    observationId: string;
+    harnessExecutionId?: string;
+    subagentKey?: string;
+    stableCorrelationId?: string;
+    toolCallId?: string;
+    toolCallRole?: SubagentToolCallRole;
+    mode?: SubagentMode;
+    status?: SubagentStatus;
+    label?: string;
+    subagentType?: string;
+    description?: string;
+    providerId?: string;
+    providerKind?: string;
+    childSessionId?: string;
+    transcript?: SubagentTranscript;
+    attention?: number;
+    /** The finished run's outcome, owed to the parent until a `wakeReceipt` names this observation. */
+    wakeResult?: {
+        status: SubagentStatus;
+        text: string;
+        assistantMessageId?: string;
+    };
+    wakeReceipt?: string;
+};
+export declare class UnknownHostSubagentKeyError extends Error {
+    readonly parentSessionId: string;
+    readonly observationId: string;
+    readonly subagentKey: string | undefined;
+    constructor(parentSessionId: string, observationId: string, subagentKey: string | undefined);
+}

package/dist/tool-header.d.ts

@@ -0,0 +1,13 @@
+import type { AgentToolPart } from "./content";
+export type ToolOpenSettings = {
+    readonly shell: boolean;
+    readonly edit: boolean;
+};
+export declare function toolOpensByDefault(tool: string, settings: ToolOpenSettings): boolean | undefined;
+/**
+ * A tool part as its collapsed row draws it: status, title, time, error and
+ * the input and metadata its header reads, marked `headerOnly` so a reader
+ * fetches the whole part, attachments included, when the row opens. A tool
+ * whose row has no body is returned whole.
+ */
+export declare function toolPartHeader(part: AgentToolPart): AgentToolPart;

package/dist/tool-names.d.ts

@@ -1,3 +1,8 @@
 export declare function canonicalToolName(name: string): string;
 /** The alias spellings themselves, for consumers that register one entry per name. */
 export declare function toolNameAliases(): ReadonlyArray<readonly [alias: string, target: string]>;
+declare const CLAXEDO_TOOL_NAMES: readonly ["task_list", "task_get", "task_create", "task_edit", "task_start", "session_create", "sessions_list", "session_get", "session_transcript", "session_send", "session_cancel_turn", "session_handoff", "session_rename", "session_delete", "session_changes", "documents_list", "documents_open", "subagent_capabilities", "create_subagent", "subagent_status", "subagent_list", "subagent_cancel", "sessions_board", "permission_reply", "question_reply", "question_reject", "wait_for_attention", "workspaces_list", "workspace_status", "workspace_checkpoint", "workspace_restore", "workspace_lifecycle", "app_plugin_create", "app_plugin_check", "app_plugin_add", "app_plugin_guide", "ui_show", "ui_guide"];
+export type ClaxedoToolName = (typeof CLAXEDO_TOOL_NAMES)[number];
+export declare function isClaxedoToolName(name: string): name is ClaxedoToolName;
+export declare function claxedoToolName(tool: string, input?: Record<string, unknown>): string | undefined;
+export {};

package/dist/transcript-notice.d.ts

@@ -0,0 +1,28 @@
+export type TranscriptNoticeSeverity = "info" | "warn" | "error";
+export type TranscriptCompaction = {
+    status: "running";
+} | {
+    status: "completed";
+} | {
+    status: "failed";
+    error: string;
+};
+export type TranscriptNotice = {
+    kind: "harness";
+    code: string;
+    message: string;
+    severity: TranscriptNoticeSeverity;
+} | {
+    kind: "agent-message";
+    sender: string;
+    senderName?: string;
+    message: string;
+    senderTaskId?: string;
+    sourceSessionId?: string;
+} | ({
+    kind: "compaction";
+} & TranscriptCompaction) | {
+    kind: "conversation-reset";
+    trigger: string;
+};
+export declare function isTranscriptNotice(value: unknown): value is TranscriptNotice;

package/dist/turn-account.d.ts

@@ -0,0 +1,26 @@
+import type { NativeSdkHarnessId } from "./harnesses";
+import { type ProviderDirect, type ProviderProjection } from "./provider-projection";
+/**
+ * The account a turn ran on: a stored credential the broker spent, named by
+ * its non-secret metadata, or the harness's own login on this machine when no
+ * credential was bound for it.
+ */
+export type TurnAccount = {
+    readonly kind: "stored";
+    readonly harnessId: NativeSdkHarnessId;
+    readonly credentialId: string;
+    readonly providerId: string;
+    readonly label?: string;
+    readonly revision?: number;
+} | {
+    readonly kind: "machine";
+    readonly harnessId: NativeSdkHarnessId;
+};
+export declare function turnAccount(input: unknown): TurnAccount | undefined;
+/**
+ * The account a turn launched on this delivery runs on: a binding, or a
+ * credential handed over direct. Nothing handed means the harness's own login
+ * on this machine; a delivery from an authority that names no account, or one
+ * that cannot be bound, names nothing.
+ */
+export declare function turnAccountFor(harnessId: NativeSdkHarnessId, delivery: ProviderProjection | ProviderDirect | undefined): TurnAccount | undefined;

package/dist/turn-error-classes.d.ts

@@ -0,0 +1,10 @@
+/**
+ * What a failed turn tells the operator to do. `rate_limit` is a temporary
+ * refusal (HTTP 429, "try again later") that the same account clears by
+ * waiting; `usage_limit` is an exhausted plan or quota window that only another
+ * model or account gets past until it resets; `egress` is the vendor's edge
+ * refusing the host the turn ran on (a challenge page, not an API answer),
+ * which says nothing about the account and clears on another connection.
+ */
+export declare const FIRST_TURN_ERROR_CLASSES: readonly ["credential", "harness", "model", "rate_limit", "usage_limit", "egress", "workspace", "session", "unknown"];
+export type FirstTurnErrorClass = (typeof FIRST_TURN_ERROR_CLASSES)[number];