qlogicagent 2.3.0 → 2.4.0

package/dist/types/protocol/wire/provider-runtime-core.d.ts

@@ -0,0 +1,147 @@
+import type { ProviderRuntimeResolvedAuthContract, ProviderRuntimeVaultErrorType } from "./provider-runtime-contract.js";
+export declare const PROVIDER_RUNTIME_OPENAI_CODEX_PROVIDER_ID = "openai-codex";
+export declare function normalizeProviderRuntimeId(provider: string): string;
+export declare function normalizeProviderRuntimeIdForAuth(provider: string): string;
+export declare const resolveProviderRuntimeKeyFamily: typeof normalizeProviderRuntimeIdForAuth;
+export type ProviderRuntimeCapabilities = {
+    anthropicToolSchemaMode: "native" | "openai-functions";
+    anthropicToolChoiceMode: "native" | "openai-string-modes";
+    providerFamily: "default" | "openai" | "anthropic";
+    preserveAnthropicThinkingSignatures: boolean;
+    openAiCompatTurnValidation: boolean;
+    providerThoughtSignatureSanitization: boolean;
+    transcriptToolCallIdMode: "default" | "strict9";
+    transcriptToolCallIdModelHints: string[];
+    providerThoughtSignatureModelHints: string[];
+    dropThinkingBlockModelHints: string[];
+};
+export declare function resolveProviderRuntimeCapabilities(provider?: string | null): ProviderRuntimeCapabilities;
+export declare function preservesProviderRuntimeAnthropicThinkingSignatures(provider?: string | null): boolean;
+export declare function requiresOpenAiCompatibleAnthropicToolPayloadForProviderRuntime(provider?: string | null): boolean;
+export declare function usesOpenAiFunctionAnthropicToolSchemaForProviderRuntime(provider?: string | null): boolean;
+export declare function usesOpenAiStringModeAnthropicToolChoiceForProviderRuntime(provider?: string | null): boolean;
+export declare function supportsOpenAiCompatTurnValidationForProviderRuntime(provider?: string | null): boolean;
+export declare function isOpenAiProviderRuntimeFamily(provider?: string | null): boolean;
+export declare function isAnthropicProviderRuntimeFamily(provider?: string | null): boolean;
+export declare function shouldDropThinkingBlocksForProviderRuntimeModel(params: {
+    provider?: string | null;
+    modelId?: string | null;
+}): boolean;
+export declare function shouldSanitizeProviderRuntimeThoughtSignaturesForModel(params: {
+    provider?: string | null;
+    modelId?: string | null;
+}): boolean;
+export declare function resolveProviderRuntimeTranscriptToolCallIdMode(provider?: string | null, modelId?: string | null): "strict9" | undefined;
+export type ProviderRuntimeCredentialRecord = {
+    type: "api_key";
+    key: string;
+} | {
+    type: string;
+    access: string;
+};
+export type ProviderRuntimeCredentialMap = Record<string, ProviderRuntimeCredentialRecord>;
+type InMemoryAuthStorageBackendLike = {
+    withLock<T>(update: (current: string) => {
+        result: T;
+        next?: string;
+    }): T;
+};
+export declare function createProviderRuntimeInMemoryAuthStorageBackend(initialData: ProviderRuntimeCredentialMap): InMemoryAuthStorageBackendLike;
+export declare function createProviderRuntimeAuthStorage<TAuthStorage>(params: {
+    AuthStorageLike: unknown;
+    authPath: string;
+    credentials: ProviderRuntimeCredentialMap;
+    createBackend?: () => InMemoryAuthStorageBackendLike;
+}): TAuthStorage;
+export type ProviderRuntimeEnvApiKeyResult = {
+    apiKey: string;
+    source: string;
+};
+export type ProviderRuntimeResolvedAuthMode = "api-key" | "oauth" | "token" | "mixed" | "aws-sdk" | "unknown";
+export type ProviderRuntimeResolvedAuth = ProviderRuntimeResolvedAuthContract & {
+    apiKey?: string;
+    profileId?: string;
+    source: string;
+    mode: "api-key" | "oauth" | "token" | "aws-sdk";
+    vaultRelease?: () => void;
+    vaultReportSuccess?: () => void;
+    vaultReportError?: (errorType?: ProviderRuntimeVaultErrorType) => void;
+};
+export type ProviderRuntimePlatformKey = {
+    key: string;
+    source: string;
+    release?: () => void;
+    reportSuccess?: () => void;
+    reportError?: (errorType?: ProviderRuntimeVaultErrorType) => void;
+};
+export declare function resolveProviderRuntimeAwsSdkEnvVarName(env?: NodeJS.ProcessEnv): string | undefined;
+export declare function resolveProviderRuntimeAwsSdkAuthInfo(params?: {
+    env?: NodeJS.ProcessEnv;
+    appliedEnvKeys?: Iterable<string>;
+}): {
+    mode: "aws-sdk";
+    source: string;
+};
+export declare const PROVIDER_RUNTIME_ENV_API_KEY_CANDIDATES: Record<string, readonly string[]>;
+export declare function listProviderRuntimeEnvApiKeyNames(): string[];
+export declare function resolveProviderRuntimeEnvApiKey(params: {
+    provider: string;
+    env?: NodeJS.ProcessEnv;
+    appliedEnvKeys?: Iterable<string>;
+    resolveSpecialApiKey?: (normalizedProvider: string, env: NodeJS.ProcessEnv, appliedEnvKeys: Set<string>) => ProviderRuntimeEnvApiKeyResult | null | undefined;
+}): ProviderRuntimeEnvApiKeyResult | null;
+export interface ProviderRuntimeAuthProfileDeps<TConfig, TStore> {
+    ensureAuthProfileStore: (agentDir?: string) => TStore;
+    listProfilesForProvider: (store: TStore, provider: string) => string[];
+    resolveAuthProfileOrder: (params: {
+        cfg?: TConfig;
+        store: TStore;
+        provider: string;
+        preferredProfile?: string;
+    }) => string[];
+    resolveApiKeyForProfile: (params: {
+        cfg?: TConfig;
+        store: TStore;
+        profileId: string;
+        agentDir?: string;
+    }) => Promise<{
+        apiKey: string;
+    } | null | undefined>;
+    getProfileType: (store: TStore, profileId: string) => string | undefined;
+}
+export interface ProviderRuntimeAuthCoreDeps<TConfig, TStore, TModel> {
+    isHubManagedProviderPathActive: () => boolean;
+    profileDeps: ProviderRuntimeAuthProfileDeps<TConfig, TStore>;
+    getCustomProviderApiKey: (cfg: TConfig | undefined, provider: string) => string | undefined;
+    resolveProviderAuthOverride: (cfg: TConfig | undefined, provider: string) => Extract<ProviderRuntimeResolvedAuthMode, "api-key" | "oauth" | "token" | "aws-sdk"> | undefined;
+    resolveEnvApiKey: (provider: string) => ProviderRuntimeEnvApiKeyResult | null | undefined;
+    normalizeProviderId?: (provider: string) => string;
+    resolveKeyFamily?: (provider: string) => string;
+    getAppliedShellEnvKeys?: () => Iterable<string>;
+    getFallbackProviders?: (provider: string) => string[];
+    tryGetPlatformKey?: (provider: string) => ProviderRuntimePlatformKey | null | undefined;
+    onPlatformKeyError?: (provider: string, error: unknown) => void;
+    getModelProvider?: (model: TModel) => string;
+    normalizeSecretInput?: (value: string | undefined) => string | undefined;
+}
+export declare function createProviderRuntimeAuthCore<TConfig, TStore, TModel>(deps: ProviderRuntimeAuthCoreDeps<TConfig, TStore, TModel>): {
+    getApiKeyForModel: (params: {
+        model: TModel;
+        cfg?: TConfig;
+        profileId?: string;
+        preferredProfile?: string;
+        store?: TStore;
+        agentDir?: string;
+    }) => Promise<ProviderRuntimeResolvedAuth>;
+    requireApiKey: (auth: ProviderRuntimeResolvedAuth, provider: string) => string;
+    resolveApiKeyForProvider: (params: {
+        provider: string;
+        cfg?: TConfig;
+        profileId?: string;
+        preferredProfile?: string;
+        store?: TStore;
+        agentDir?: string;
+    }) => Promise<ProviderRuntimeResolvedAuth>;
+    resolveModelAuthMode: (provider?: string, cfg?: TConfig, store?: TStore) => ProviderRuntimeResolvedAuthMode | undefined;
+};
+export {};

package/dist/types/protocol/wire/provider-runtime-io.d.ts

@@ -0,0 +1,20 @@
+import { type ProviderRuntimeCredentialMap } from "./provider-runtime-core.js";
+export declare function scrubProviderRuntimeStaticAuthJsonEntries(pathname: string): void;
+type InMemoryAuthStorageBackendLike = {
+    withLock<T>(update: (current: string) => {
+        result: T;
+        next?: string;
+    }): T;
+};
+export declare function discoverProviderRuntimeAuthStorage<TAuthStorage>(params: {
+    agentDir: string;
+    AuthStorageLike: unknown;
+    credentials: ProviderRuntimeCredentialMap;
+    createBackend?: () => InMemoryAuthStorageBackendLike;
+}): TAuthStorage;
+export declare function createProviderRuntimeModelRegistry<TAuthStorage, TModelRegistry>(params: {
+    authStorage: TAuthStorage;
+    ModelRegistryLike: new (authStorage: TAuthStorage, modelsPath: string) => TModelRegistry;
+    agentDir: string;
+}): TModelRegistry;
+export {};

package/dist/types/protocol/wire/resource-manifest.d.ts

@@ -0,0 +1,68 @@
+export declare const RESOURCE_MANIFEST_SCHEMA_VERSION = 2;
+export declare const RUNTIME_ASSET_IDS: {
+    readonly gatewayImage: "gateway.image.desktop-slim";
+    readonly whisperModelTiny: "speech.whisper.model.tiny";
+    readonly ffmpegWin32X64: "runtime.ffmpeg.win32-x64";
+    readonly nodeWin32X64: "runtime.node.win32-x64";
+    readonly dockerDesktopWin32X64: "runtime.docker-desktop.win32-x64";
+    readonly dockerDesktopDarwinX64: "runtime.docker-desktop.darwin-x64";
+    readonly dockerDesktopDarwinArm64: "runtime.docker-desktop.darwin-arm64";
+};
+export declare const RUNTIME_PROFILE_IDS: {
+    readonly desktopDockerBridge: "desktop.docker-bridge";
+    readonly desktopEmbeddedWin32X64: "desktop.embedded.win32-x64";
+};
+export type RuntimeResourcePlatform = 'any' | 'win32-x64' | 'win32-arm64' | 'darwin-x64' | 'darwin-arm64' | 'linux-x64' | 'linux-arm64';
+export type RuntimeResourceAssetKind = 'container-image' | 'model' | 'runtime' | 'installer';
+export type RuntimeResourceAssetDelivery = 'remote' | 'bundled';
+export interface RuntimeResourceArtifact {
+    label?: string;
+    fileName: string;
+    size?: number;
+    sha256?: string;
+    url?: string;
+    relativePath?: string;
+}
+export interface RuntimeResourceAsset {
+    id: string;
+    version: string;
+    title: string;
+    kind: RuntimeResourceAssetKind;
+    delivery: RuntimeResourceAssetDelivery;
+    platform: RuntimeResourcePlatform;
+    description?: string;
+    artifacts: RuntimeResourceArtifact[];
+}
+export interface RuntimeResourceProfile {
+    id: string;
+    title: string;
+    platform: RuntimeResourcePlatform;
+    assetIds: string[];
+    description?: string;
+}
+export type RuntimeResourceAssetMap = Record<string, RuntimeResourceAsset>;
+export type RuntimeResourceProfileMap = Record<string, RuntimeResourceProfile>;
+export interface RuntimeManifestShortcutEntry {
+    version: string;
+    sha256: string;
+    size: number;
+    url: string;
+}
+export interface RuntimeResourceManifest {
+    schemaVersion: number;
+    channel?: string;
+    publishedAt?: string;
+    minElectronVersion?: string;
+    releaseNotes?: string;
+    assets: RuntimeResourceAssetMap;
+    profiles: RuntimeResourceProfileMap;
+    gateway?: RuntimeManifestShortcutEntry;
+    whisperModel?: RuntimeManifestShortcutEntry;
+}
+export declare function createDefaultRuntimeResourceProfiles(): RuntimeResourceProfileMap;
+export declare function getRuntimeResourceAsset(manifest: Pick<RuntimeResourceManifest, 'assets'>, assetId: string): RuntimeResourceAsset | undefined;
+export declare function getRuntimeResourceProfile(manifest: Pick<RuntimeResourceManifest, 'profiles'>, profileId: string): RuntimeResourceProfile | undefined;
+export declare function getRuntimeResourceProfileAssets(manifest: Pick<RuntimeResourceManifest, 'assets' | 'profiles'>, profileId: string): RuntimeResourceAsset[];
+export declare function upsertRuntimeResourceAsset(manifest: RuntimeResourceManifest, asset: RuntimeResourceAsset): RuntimeResourceManifest;
+export declare function getManifestShortcutEntry(asset?: RuntimeResourceAsset): RuntimeManifestShortcutEntry | undefined;
+export declare function normalizeRuntimeResourceManifest(raw: unknown): RuntimeResourceManifest;

package/dist/types/protocol/wire/session.d.ts

@@ -0,0 +1,32 @@
+export interface SessionIdentityContract {
+    sessionId: string;
+    sessionKey: string;
+}
+export type ModelSelectionReason = "user-selected" | "auto-default" | "failover" | "fallback" | "manual-switch";
+export interface RuntimeCapabilitySummaryContract {
+    installedCapabilities: string[];
+    enabledCapabilities: string[];
+    eligibleToolCount?: number;
+    ineligibleToolCount?: number;
+}
+export interface ApprovalRequiredToolContract {
+    toolName: string;
+    reasonCodes?: string[];
+}
+export interface RuntimeSessionContract extends SessionIdentityContract {
+    createdAt: number;
+    lastTouchedAt: number;
+    activeRunId: string | null;
+    requestedModel?: string;
+    resolvedModel?: string;
+    modelSelectionReason?: ModelSelectionReason;
+    capabilitySnapshotVersion?: string;
+    capabilitySummary?: RuntimeCapabilitySummaryContract;
+    approvalRequiredTools?: ApprovalRequiredToolContract[];
+}
+export interface PendingPromptContract extends SessionIdentityContract {
+    idempotencyKey: string;
+    sentTextLength?: number;
+    sentText?: string;
+    toolCallIds?: string[];
+}

package/dist/types/protocol/wire/thread-protocol.d.ts

@@ -0,0 +1,157 @@
+/**
+ * Thread Protocol — Codex app-server style three-layer abstraction.
+ *
+ * Thread → Turn → Item
+ *
+ *  Thread: persistent conversation container (maps to a session)
+ *  Turn: one user request → agent response cycle
+ *  Item: individual components within a turn (message, tool_call, tool_result, etc.)
+ *
+ * This module defines the wire types. The existing `agent.turn` RPC continues
+ * to work; these types provide the foundation for `thread/*` methods.
+ */
+export type ItemType = "message" | "tool_call" | "tool_result" | "tool_blocked" | "recovery" | "plan_update" | "skill_instruction";
+export type ItemRole = "user" | "assistant" | "system";
+/** A single atomic event within a turn. */
+export interface ThreadItem {
+    /** Unique item ID. */
+    id: string;
+    /** Item type (discriminator). */
+    type: ItemType;
+    /** Role of the actor. */
+    role: ItemRole;
+    /** Text content (for message items). */
+    text?: string;
+    /** Tool name (for tool_call / tool_result items). */
+    toolName?: string;
+    /** Tool call ID (LLM-assigned). */
+    toolCallId?: string;
+    /** Serialized arguments (for tool_call). */
+    arguments?: string;
+    /** Tool output (for tool_result). */
+    output?: string;
+    /** Whether the tool was approved. */
+    approved?: boolean;
+    /** Recovery strategy used (for recovery items). */
+    strategy?: string;
+    /** Timestamp (ISO 8601). */
+    createdAt: string;
+}
+export type TurnStatus = "pending" | "in_progress" | "completed" | "failed" | "aborted";
+/** Represents one user request → agent response cycle. */
+export interface ThreadTurn {
+    /** Unique turn ID. */
+    id: string;
+    /** Thread this turn belongs to. */
+    threadId: string;
+    /** Turn status. */
+    status: TurnStatus;
+    /** Items produced during this turn. */
+    items: ThreadItem[];
+    /** Model used for this turn. */
+    model?: string;
+    /** Token usage. */
+    usage?: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
+    /** Cost in USD. */
+    costUSD?: number;
+    /** Turn creation time. */
+    createdAt: string;
+    /** Turn completion time. */
+    completedAt?: string;
+}
+export type ThreadStatus = "active" | "archived" | "deleted";
+/** Persistent conversation container. */
+export interface Thread {
+    /** Unique thread ID (maps to session ID). */
+    id: string;
+    /** Display title (auto-generated or user-set). */
+    title?: string;
+    /** Thread status. */
+    status: ThreadStatus;
+    /** All turns in this thread. */
+    turns: ThreadTurn[];
+    /** Working directory. */
+    cwd?: string;
+    /** Thread creation time. */
+    createdAt: string;
+    /** Last activity time. */
+    lastActiveAt: string;
+}
+/**
+ * `initialize` request params — superset of agent.hello.
+ * Sent by host as the first message after transport connects.
+ */
+export interface InitializeParams {
+    /** Protocol version. */
+    protocolVersion: string;
+    /** Host application info. */
+    host: {
+        name: string;
+        version: string;
+    };
+    /** Host capabilities. */
+    capabilities?: {
+        /** Host can receive streaming deltas. */
+        streaming?: boolean;
+        /** Host supports tool approval flow. */
+        toolApproval?: boolean;
+        /** Host supports thread persistence. */
+        threads?: boolean;
+    };
+    /** Optional initial configuration. */
+    config?: Record<string, unknown>;
+}
+/** `initialize` response result. */
+export interface InitializeResult {
+    /** Agent protocol version. */
+    protocolVersion: string;
+    /** Agent info. */
+    agent: {
+        name: string;
+        version: string;
+    };
+    /** Agent capabilities. */
+    capabilities: {
+        tools: string[];
+        streaming: boolean;
+        threads: boolean;
+    };
+}
+/** `thread/create` params. */
+export interface ThreadCreateParams {
+    /** Optional thread ID (auto-generated if not provided). */
+    id?: string;
+    /** Optional title. */
+    title?: string;
+    /** Working directory. */
+    cwd?: string;
+    /** LLM configuration. */
+    config?: Record<string, unknown>;
+}
+/** `thread/turn` params — submit a user message to a thread. */
+export interface ThreadTurnParams {
+    /** Thread ID. */
+    threadId: string;
+    /** User message(s). */
+    messages: Array<{
+        role: "user";
+        content: string;
+    }>;
+    /** Override LLM config for this turn. */
+    config?: Record<string, unknown>;
+}
+/** `thread/list` result. */
+export interface ThreadListResult {
+    threads: Array<{
+        id: string;
+        title?: string;
+        status: ThreadStatus;
+        turnCount: number;
+        createdAt: string;
+        lastActiveAt: string;
+    }>;
+}

package/dist/types/protocol/wire/transport.d.ts

@@ -0,0 +1,57 @@
+export type ProxyLocale = "cn" | "intl";
+export type ProxyKeySource = "managed" | "user";
+export type ProxyQuotaSource = "subscription" | "topup" | "free" | "own-key";
+export type ProxyRequestCategory = "text" | "image" | "video" | "music" | "audio" | "vision";
+export interface TransportUsageInfo {
+    input: number;
+    output: number;
+    cacheRead?: number;
+}
+export interface TransportResponsePayload {
+    statusCode: number;
+    body: string;
+    usage?: TransportUsageInfo;
+}
+export interface TransportResponseMsg {
+    type: "proxy.response";
+    id: string;
+    payload: TransportResponsePayload;
+}
+export interface TransportErrorPayload {
+    error: string;
+    code: string;
+    retryable: boolean;
+}
+export interface TransportErrorMsg {
+    type: "proxy.error";
+    id: string;
+    payload: TransportErrorPayload;
+}
+export interface TransportBillingInfo {
+    premiumCost: number;
+    tier: string;
+    provider: string;
+    model: string;
+    requestCategory?: ProxyRequestCategory;
+    quotaSource?: ProxyQuotaSource;
+    keySource?: ProxyKeySource;
+}
+export interface AgentExecutionRefs {
+    executionId?: string;
+    rootExecutionId?: string;
+    parentExecutionId?: string;
+    sidechainId?: string;
+    attemptId?: string;
+    outcomeId?: string;
+}
+export type AgentExecutionSource = "turn" | "resume" | "replay" | "sidechain";
+export type AgentAttemptSource = "primary" | "retry" | "fallback" | "repair";
+export type AgentSidechainType = "research" | "planner" | "plan-repair" | "code-repair" | "media-prep" | "custom";
+export type AgentSidechainRole = "leaf" | "orchestrator";
+export type AgentSidechainMergePolicy = "summary-only" | "append-messages" | "replace-context" | "manual";
+export type AgentExecutionSessionStatus = "running" | "interrupted" | "completed" | "failed" | "cancelled";
+export type ControlApprovalDecision = "approved" | "denied" | "expired" | "cancelled";
+export type ControlApprovalSource = "user" | "policy" | "system" | "replay";
+export type ExecutionInterruptReason = "approval-wait" | "gateway-disconnected" | "policy-pause" | "user-pause" | "tool-backpressure" | "lease-expired";
+export type ExecutionResumeSource = "user" | "gateway-reconnect" | "policy" | "system";
+export type ExecutionCancelReason = "user-cancel" | "policy-cancel" | "lease-expired" | "superseded" | "branch-cancel";

package/dist/types/protocol/wire/turn.d.ts

@@ -0,0 +1,208 @@
+import type { AgentExecutionRefs, TransportResponsePayload, TransportUsageInfo, TransportBillingInfo } from "./transport.js";
+import type { ModelSelectionReason } from "./session.js";
+import type { TransportCapabilitySummaryContract, TransportApprovalRequiredToolHintEntry, TransportToolEligibilitySummaryEntry, ToolExecutionStepContext, ToolInvokeApprovalDescriptor, AgentTurnConversation, AgentTurnExperience, AgentTurnRequestSpec, AgentTurnLocalContext, AgentTurnClientHints } from "./capability-transport.js";
+export interface AgentTurnStartPayload extends AgentExecutionRefs {
+    sessionId: string;
+    turnId: string;
+    deviceId?: string;
+    principalId?: string;
+    entitlementId?: string;
+    subscriptionKey?: string;
+    conversation: AgentTurnConversation;
+    experience?: AgentTurnExperience;
+    request?: AgentTurnRequestSpec;
+    localContext?: AgentTurnLocalContext;
+    clientHints?: AgentTurnClientHints;
+}
+export interface AgentTurnStartMsg extends AgentTurnStartPayload {
+    type: "agent.turn.start";
+    id: string;
+}
+export interface AgentTurnThinkingPayload extends AgentExecutionRefs {
+    sessionId: string;
+    turnId: string;
+    stage?: "routing" | "execution" | "tool-wait";
+    message?: string;
+}
+export interface AgentTurnThinkingMsg {
+    type: "agent.turn.thinking";
+    id: string;
+    payload: AgentTurnThinkingPayload;
+}
+export interface AgentTurnDeltaPayload extends AgentExecutionRefs {
+    sessionId: string;
+    turnId: string;
+    chunk: string;
+}
+export interface AgentTurnDeltaMsg {
+    type: "agent.turn.delta";
+    id: string;
+    payload: AgentTurnDeltaPayload;
+}
+export interface AgentTurnToolPlannedPayload extends AgentExecutionRefs {
+    sessionId: string;
+    turnId: string;
+    callId: string;
+    toolName: string;
+    arguments?: Record<string, unknown>;
+    approvalMode?: "user-confirm" | "pre-authorized";
+}
+export interface AgentTurnToolPlannedMsg {
+    type: "agent.turn.tool-planned";
+    id: string;
+    payload: AgentTurnToolPlannedPayload;
+}
+export interface AgentTurnToolRunningPayload extends AgentExecutionRefs {
+    sessionId: string;
+    turnId: string;
+    callId: string;
+    toolName: string;
+}
+export interface AgentTurnToolRunningMsg {
+    type: "agent.turn.tool-running";
+    id: string;
+    payload: AgentTurnToolRunningPayload;
+}
+export interface AgentTurnCompletedPayload extends AgentExecutionRefs {
+    sessionId: string;
+    turnId: string;
+    outcomeId: string;
+    resolvedModel?: string;
+    modelSelectionReason?: ModelSelectionReason;
+    capabilitySummary?: TransportCapabilitySummaryContract;
+    approvalRequiredToolHint?: TransportApprovalRequiredToolHintEntry[];
+    eligibleToolSummary?: TransportToolEligibilitySummaryEntry[];
+    ineligibleToolSummary?: TransportToolEligibilitySummaryEntry[];
+    response?: TransportResponsePayload;
+    usage?: TransportUsageInfo;
+    billed?: TransportBillingInfo | null;
+}
+export interface AgentTurnCompletedMsg {
+    type: "agent.turn.completed";
+    id: string;
+    payload: AgentTurnCompletedPayload;
+}
+export interface BillingRecordedPayload extends AgentExecutionRefs {
+    sessionId: string;
+    turnId: string;
+    outcomeId: string;
+    billed: TransportBillingInfo;
+}
+export interface BillingRecordedMsg {
+    type: "billing.recorded";
+    id: string;
+    payload: BillingRecordedPayload;
+}
+export interface AgentTurnFailedPayload extends AgentExecutionRefs {
+    sessionId: string;
+    turnId: string;
+    outcomeId: string;
+    code: string;
+    error: string;
+    retryable: boolean;
+}
+export interface AgentTurnFailedMsg {
+    type: "agent.turn.failed";
+    id: string;
+    payload: AgentTurnFailedPayload;
+}
+export interface ToolInvokePlannedPayload extends AgentExecutionRefs, ToolExecutionStepContext {
+    sessionId: string;
+    turnId: string;
+    callId: string;
+    toolName: string;
+    arguments?: Record<string, unknown>;
+    approvalMode?: "user-confirm" | "pre-authorized";
+}
+export interface ToolInvokePlannedMsg {
+    type: "tool.invoke.planned";
+    id: string;
+    payload: ToolInvokePlannedPayload;
+}
+export interface ToolInvokeStartedPayload extends AgentExecutionRefs, ToolExecutionStepContext {
+    sessionId: string;
+    turnId: string;
+    callId: string;
+    toolName: string;
+}
+export interface ToolInvokeStartedMsg {
+    type: "tool.invoke.started";
+    id: string;
+    payload: ToolInvokeStartedPayload;
+}
+export interface ToolInvokeRequestPayload extends AgentExecutionRefs, ToolExecutionStepContext {
+    sessionId: string;
+    turnId: string;
+    callId: string;
+    tool: {
+        name: string;
+        arguments: Record<string, unknown>;
+    };
+    approval?: ToolInvokeApprovalDescriptor;
+}
+export interface ToolInvokeRequestMsg {
+    type: "tool.invoke.request";
+    id: string;
+    payload: ToolInvokeRequestPayload;
+}
+export interface ToolInvokeResultPayload extends AgentExecutionRefs, ToolExecutionStepContext {
+    sessionId: string;
+    turnId: string;
+    callId: string;
+    outcomeId: string;
+    ok: boolean;
+    payload?: unknown;
+    error?: string;
+}
+export interface ToolInvokeResultMsg {
+    type: "tool.invoke.result";
+    id: string;
+    payload: ToolInvokeResultPayload;
+}
+export type LocalExecutionEnvelopeKind = "started" | "partial" | "checkpoint" | "artifact" | "final" | "error";
+export type LocalExecutionEnvelopeStage = "turn" | "tool" | "checkpoint" | "artifact" | "control" | "memory";
+export interface LocalExecutionEnvelopePayload extends AgentExecutionRefs, ToolExecutionStepContext {
+    sessionId: string;
+    turnId?: string;
+    kind: LocalExecutionEnvelopeKind;
+    stage: LocalExecutionEnvelopeStage;
+    eventType: string;
+    emittedAtMs: number;
+    callId?: string;
+    approvalId?: string;
+    checkpointId?: string;
+    restoreId?: string;
+    summary?: string;
+    data?: Record<string, unknown>;
+}
+export interface LocalExecutionEnvelopeMsg {
+    type: "local.execution.envelope";
+    id: string;
+    payload: LocalExecutionEnvelopePayload;
+}
+export interface AgentSkillCreatePayload {
+    sessionId: string;
+    turnId: string;
+    executionId?: string;
+    suggestedName: string;
+    description: string;
+    tools: string[];
+    stepCount: number;
+}
+export interface AgentSkillCreateMsg {
+    type: "agent.skill.create";
+    id: string;
+    payload: AgentSkillCreatePayload;
+}
+export interface AgentSkillImprovePayload {
+    sessionId: string;
+    turnId: string;
+    executionId?: string;
+    skillName: string;
+    reason: string;
+}
+export interface AgentSkillImproveMsg {
+    type: "agent.skill.improve";
+    id: string;
+    payload: AgentSkillImprovePayload;
+}