@moxt-ai/mobius-protocol 0.0.10 → 0.0.11

package/dist/daemon-transport.d.ts

@@ -0,0 +1,587 @@
+interface MessageSignature<TMessage extends {
+    readonly kind: string;
+}> {
+    readonly decoder: (encoded: string) => TMessage;
+    readonly encoder: (message: unknown) => string;
+    readonly kind: TMessage["kind"];
+    readonly schema: (message: unknown) => TMessage;
+}
+declare const serviceToDaemonSignatures: {
+    readonly "agent.catalog.refresh": MessageSignature<Readonly<{
+        kind: "agent.catalog.refresh";
+        requestId: string;
+    }>>;
+    readonly "agent.integration.install.cancel": MessageSignature<Readonly<{
+        kind: "agent.integration.install.cancel";
+        requestId: string;
+    }>>;
+    readonly "agent.integration.install.request": MessageSignature<Readonly<{
+        agentId: string;
+        requestId: string;
+        kind: "agent.integration.install.request";
+    }>>;
+    readonly "agent.settings.discover": MessageSignature<Readonly<{
+        agentId: string;
+        kind: "agent.settings.discover";
+        model?: string | undefined;
+        requestId: string;
+    }>>;
+    readonly "file.read": MessageSignature<Readonly<{
+        kind: "file.read";
+        maxBytes: number;
+        requestId: string;
+        sessionId: string;
+        path: string;
+    }>>;
+    readonly "native.session.cancel": MessageSignature<Readonly<{
+        requestId: string;
+        sessionId: string;
+        kind: "native.session.cancel";
+    }>>;
+    readonly "native.session.request": MessageSignature<Readonly<{
+        requestId: string;
+        sessionId: string;
+        kind: "native.session.request";
+        additionalDirectoryIds: readonly string[];
+        agentId: string;
+        bindingId: string;
+        directoryId: string;
+        action: "preview";
+        entryId: string;
+    }> | Readonly<{
+        requestId: string;
+        sessionId: string;
+        kind: "native.session.request";
+        additionalDirectoryIds: readonly string[];
+        agentId: string;
+        bindingId: string;
+        directoryId: string;
+        action: "find";
+        nativeSessionId: string;
+    }> | Readonly<{
+        requestId: string;
+        sessionId: string;
+        kind: "native.session.request";
+        additionalDirectoryIds: readonly string[];
+        agentId: string;
+        bindingId: string;
+        directoryId: string;
+        action: "list";
+        cursor: string | null;
+    }> | Readonly<{
+        requestId: string;
+        sessionId: string;
+        kind: "native.session.request";
+        additionalDirectoryIds: readonly string[];
+        agentId: string;
+        bindingId: string;
+        directoryId: string;
+        action: "fork" | "import";
+        entryId: string;
+        targetSessionId: string;
+    }> | Readonly<{
+        requestId: string;
+        sessionId: string;
+        kind: "native.session.request";
+        additionalDirectoryIds: readonly string[];
+        agentId: string;
+        bindingId: string;
+        directoryId: string;
+        action: "delete";
+        entryId: string;
+    }>>;
+    readonly "native.session.turn-fork": MessageSignature<Readonly<{
+        additionalDirectoryIds: readonly string[];
+        agentId: string;
+        bindingId: string;
+        directoryId: string;
+        requestId: string;
+        sessionId: string;
+        sourceCommandId: string;
+        targetSessionId: string;
+        kind: "native.session.turn-fork";
+        messageFingerprint: string;
+        messageId: string;
+        messageOccurrence: number;
+        title: string;
+    }>>;
+    readonly "runtime.delivery": MessageSignature<import("./messages.ts").RuntimeDelivery>;
+    readonly "runtime.delivery.committed": MessageSignature<import("./messages.ts").RuntimeDeliveryCommitted>;
+    readonly "runtime.heartbeat.ack": MessageSignature<import("./messages.ts").RuntimeHeartbeatAckEvent>;
+    readonly "runtime.liveness.ready": MessageSignature<import("./messages.ts").RuntimeLivenessReadyEvent>;
+    readonly "session.cancel": MessageSignature<import("./messages.ts").SessionCancelCommand>;
+    readonly "session.configure": MessageSignature<Readonly<{
+        additionalDirectoryIds: readonly string[];
+        agentId: string;
+        bindingId: string;
+        directoryId: string;
+        sessionId: string;
+        booleanValue: boolean;
+        configId: string;
+        kind: "session.configure";
+        requestId: string;
+        value: string;
+        valueType: "boolean" | "select";
+    }>>;
+    readonly "session.elicitation.respond": MessageSignature<Readonly<{
+        action: "accept" | "cancel" | "decline";
+        content: string;
+        interactionId: string;
+        kind: "session.elicitation.respond";
+        sessionId: string;
+    }>>;
+    readonly "session.event.ack": MessageSignature<Readonly<{
+        cursor: string;
+        duplicate: boolean;
+        eventId: string;
+        kind: "session.event.ack";
+        sequence: string;
+        sessionId: string;
+    }>>;
+    readonly "session.event.deferred": MessageSignature<Readonly<{
+        eventId: string;
+        kind: "session.event.deferred";
+        retryAfterMilliseconds: number;
+        sessionId: string;
+    }>>;
+    readonly "session.event.rejected": MessageSignature<Readonly<{
+        code: "session_deleted" | "session_not_found" | "session_rejected";
+        eventId: string;
+        kind: "session.event.rejected";
+        sessionId: string;
+    }>>;
+    readonly "session.live-history.load": MessageSignature<Readonly<{
+        additionalDirectoryIds: readonly string[];
+        agentId: string;
+        bindingId: string;
+        directoryId: string;
+        kind: "session.live-history.load";
+        requestId: string;
+        sessionId: string;
+    }>>;
+    readonly "session.permission.respond": MessageSignature<Readonly<{
+        interactionId: string;
+        kind: "session.permission.respond";
+        optionId: string;
+        outcome: "cancelled" | "selected";
+        sessionId: string;
+    }>>;
+    readonly "session.prepare": MessageSignature<Readonly<{
+        additionalDirectoryIds: readonly string[];
+        agentId: string;
+        bindingId: string;
+        directoryId: string;
+        sessionId: string;
+        configuration?: Readonly<{
+            booleanValue: boolean;
+            configId: string;
+            value: string;
+            valueType: "boolean" | "select";
+        }> | undefined;
+        kind: "session.prepare";
+        requestId: string;
+        sessionState?: "provisioned" | undefined;
+        transient?: boolean | undefined;
+    }>>;
+    readonly "session.prompt": MessageSignature<import("./messages.ts").SessionPromptCommand>;
+    readonly "workspace.list": MessageSignature<Readonly<{
+        bindingId: string;
+        directoryId: string;
+        kind: "workspace.list";
+        requestId: string;
+    }>>;
+};
+export type ServiceToDaemonMessage = ReturnType<(typeof serviceToDaemonSignatures)[keyof typeof serviceToDaemonSignatures]["decoder"]>;
+export declare function decodeServiceToDaemonMessage(encoded: string): ServiceToDaemonMessage;
+export declare function encodeServiceToDaemonMessage(message: ServiceToDaemonMessage): string;
+declare const daemonToServiceSignatures: {
+    readonly "agent.catalog.refreshed": MessageSignature<Readonly<{
+        kind: "agent.catalog.refreshed";
+        requestId: string;
+    }>>;
+    readonly "agent.catalog.refresh.failed": MessageSignature<Readonly<{
+        code: string;
+        kind: "agent.catalog.refresh.failed";
+        message: string;
+        requestId: string;
+    }>>;
+    readonly "agent.integration.install.cancelled": MessageSignature<Readonly<{
+        agentId: string;
+        requestId: string;
+        kind: "agent.integration.install.cancelled";
+    }>>;
+    readonly "agent.integration.install.completed": MessageSignature<Readonly<{
+        agentId: string;
+        requestId: string;
+        authenticationMayBeRequired: boolean;
+        kind: "agent.integration.install.completed";
+    }>>;
+    readonly "agent.integration.install.failed": MessageSignature<Readonly<{
+        agentId: string;
+        requestId: string;
+        code: string;
+        kind: "agent.integration.install.failed";
+        message: string;
+    }>>;
+    readonly "agent.integration.install.progress": MessageSignature<Readonly<{
+        agentId: string;
+        requestId: string;
+        kind: "agent.integration.install.progress";
+        stage: "checking_acp" | "downloading" | "installing_adapter" | "installing_agent" | "verifying";
+    }>>;
+    readonly "agent.integration.install.started": MessageSignature<Readonly<{
+        agentId: string;
+        requestId: string;
+        kind: "agent.integration.install.started";
+    }>>;
+    readonly "agent.settings.discovered": MessageSignature<Readonly<{
+        agentId: string;
+        agentName: string;
+        agentVersion: string;
+        kind: "agent.settings.discovered";
+        modelEffort: Readonly<{
+            effortSettingId: string;
+            modelSettingId: string;
+            resolution: "complete" | "on_model_selection" | "unavailable";
+            unsupportedModelIds: readonly string[];
+            valuesByModel: Readonly<Record<string, readonly Readonly<{
+                description: string;
+                groupId: string;
+                groupName: string;
+                name: string;
+                value: string;
+            }>[]>>;
+        }>;
+        requestId: string;
+        settings: readonly Readonly<{
+            booleanValue: boolean;
+            category: string;
+            defaultValue: string;
+            description: string;
+            id: string;
+            name: string;
+            type: "boolean" | "select";
+            values: readonly Readonly<{
+                description: string;
+                groupId: string;
+                groupName: string;
+                name: string;
+                value: string;
+            }>[];
+        }>[];
+        settingsRevision: string;
+    }>>;
+    readonly "agent.settings.discovery.failed": MessageSignature<Readonly<{
+        code: string;
+        kind: "agent.settings.discovery.failed";
+        message: string;
+        requestId: string;
+    }>>;
+    readonly "file.begin": MessageSignature<Readonly<{
+        byteLength: number;
+        kind: "file.begin";
+        mediaType: string;
+        modifiedAt: string;
+        name: string;
+        requestId: string;
+        sessionId: string;
+    }>>;
+    readonly "file.chunk": MessageSignature<Readonly<{
+        data: string;
+        kind: "file.chunk";
+        requestId: string;
+        sequence: number;
+        sessionId: string;
+    }>>;
+    readonly "file.end": MessageSignature<Readonly<{
+        kind: "file.end";
+        requestId: string;
+        sessionId: string;
+    }>>;
+    readonly "file.failed": MessageSignature<Readonly<{
+        code: string;
+        kind: "file.failed";
+        message: string;
+        requestId: string;
+        sessionId: string;
+    }>>;
+    readonly "native.session.result": MessageSignature<Readonly<{
+        requestId: string;
+        sessionId: string;
+        kind: "native.session.result";
+        action: "find";
+        entry: Readonly<{
+            entryId: string;
+            title: string;
+            directoryId: string;
+            directoryLabel: string;
+            updatedAt: string | null;
+            additionalDirectories: readonly Readonly<{
+                directoryId: string;
+                name: string;
+            }>[];
+        }>;
+    }> | Readonly<{
+        requestId: string;
+        sessionId: string;
+        kind: "native.session.result";
+        action: "list";
+        capabilities: Readonly<{
+            additionalDirectories: boolean;
+            audioPrompt: boolean;
+            closeSession: boolean;
+            deleteSession: boolean;
+            embeddedContextPrompt: boolean;
+            imagePrompt: boolean;
+            listSessions: boolean;
+            loadSession: boolean;
+            promptQueueing: boolean;
+            resumeSession: boolean;
+            steering: boolean;
+            unstableForkSession: boolean;
+        }>;
+        entries: readonly Readonly<{
+            entryId: string;
+            title: string;
+            directoryId: string;
+            directoryLabel: string;
+            updatedAt: string | null;
+            additionalDirectories: readonly Readonly<{
+                directoryId: string;
+                name: string;
+            }>[];
+        }>[];
+        nextCursor: string | null;
+    }> | Readonly<{
+        requestId: string;
+        sessionId: string;
+        kind: "native.session.result";
+        action: "fork" | "import";
+        targetSessionId: string;
+        ready: Readonly<{
+            additionalDirectories: readonly Readonly<{
+                directoryId: string;
+                name: string;
+            }>[];
+            agentId: string;
+            agentName: string;
+            agentVersion: string;
+            capabilities: Readonly<{
+                additionalDirectories: boolean;
+                audioPrompt: boolean;
+                closeSession: boolean;
+                deleteSession: boolean;
+                embeddedContextPrompt: boolean;
+                imagePrompt: boolean;
+                listSessions: boolean;
+                loadSession: boolean;
+                promptQueueing: boolean;
+                resumeSession: boolean;
+                steering: boolean;
+                unstableForkSession: boolean;
+            }>;
+            commands: readonly Readonly<{
+                description: string;
+                inputHint: string;
+                name: string;
+            }>[];
+            configOptions: readonly Readonly<{
+                booleanValue: boolean;
+                category: string;
+                currentValue: string;
+                description: string;
+                id: string;
+                name: string;
+                type: "boolean" | "select";
+                values: readonly Readonly<{
+                    description: string;
+                    groupId: string;
+                    groupName: string;
+                    name: string;
+                    value: string;
+                }>[];
+            }>[];
+            directoryId: string;
+            directoryLabel: string;
+            kind: "session.ready";
+            requestId: string;
+            restored: boolean;
+            runtimeTimings?: readonly Readonly<{
+                durationMilliseconds: number;
+                name: string;
+            }>[] | undefined;
+            sessionId: string;
+        }>;
+        history: Readonly<{
+            status: "available";
+            messages: readonly Readonly<{
+                role: "assistant" | "user";
+                text: string;
+                images?: readonly Readonly<{
+                    data: string;
+                    mimeType: "image/gif" | "image/jpeg" | "image/png" | "image/webp";
+                    name: string;
+                }>[] | undefined;
+            }>[];
+            truncated: boolean;
+            coveredCommandIds: readonly string[];
+            coveredMessageIds: readonly string[];
+        }> | Readonly<{
+            status: "unavailable";
+        }>;
+        title: string;
+    }> | Readonly<{
+        requestId: string;
+        sessionId: string;
+        kind: "native.session.result";
+        action: "preview";
+        entryId: string;
+        targetSessionId: string;
+        reason: "continuation_unavailable" | "requested";
+        history: Readonly<{
+            status: "available";
+            messages: readonly Readonly<{
+                role: "assistant" | "user";
+                text: string;
+                images?: readonly Readonly<{
+                    data: string;
+                    mimeType: "image/gif" | "image/jpeg" | "image/png" | "image/webp";
+                    name: string;
+                }>[] | undefined;
+            }>[];
+            truncated: boolean;
+            coveredCommandIds: readonly string[];
+            coveredMessageIds: readonly string[];
+        }> | Readonly<{
+            status: "unavailable";
+        }>;
+        title: string;
+    }> | Readonly<{
+        requestId: string;
+        sessionId: string;
+        kind: "native.session.result";
+        action: "delete";
+        entryId: string;
+        deletedSessionIds: readonly string[];
+    }>>;
+    readonly "runtime.delivery.received": MessageSignature<import("./messages.ts").RuntimeDeliveryReceived>;
+    readonly "runtime.heartbeat": MessageSignature<import("./messages.ts").RuntimeHeartbeatEvent>;
+    readonly "session.event": MessageSignature<Readonly<{
+        eventId: string;
+        kind: "session.event";
+        payload: string;
+        sessionId: string;
+        source: Readonly<{
+            attemptId: string;
+            kind: "attempt";
+            sourceSeq: string;
+        }> | Readonly<{
+            kind: "runtime";
+            sourceSeq: string;
+        }>;
+    }>>;
+    readonly "session.operation.failed": MessageSignature<Readonly<{
+        code: string;
+        kind: "session.operation.failed";
+        message: string;
+        requestId: string;
+        runtimeTimings?: readonly Readonly<{
+            durationMilliseconds: number;
+            name: string;
+        }>[] | undefined;
+        sessionId: string;
+    }>>;
+    readonly "session.live-history.loaded": MessageSignature<Readonly<{
+        history: Readonly<{
+            status: "available";
+            messages: readonly Readonly<{
+                role: "assistant" | "user";
+                text: string;
+                images?: readonly Readonly<{
+                    data: string;
+                    mimeType: "image/gif" | "image/jpeg" | "image/png" | "image/webp";
+                    name: string;
+                }>[] | undefined;
+            }>[];
+            truncated: boolean;
+            coveredCommandIds: readonly string[];
+            coveredMessageIds: readonly string[];
+        }> | Readonly<{
+            status: "unavailable";
+        }>;
+        kind: "session.live-history.loaded";
+        requestId: string;
+        sessionId: string;
+    }>>;
+    readonly "session.ready": MessageSignature<Readonly<{
+        additionalDirectories: readonly Readonly<{
+            directoryId: string;
+            name: string;
+        }>[];
+        agentId: string;
+        agentName: string;
+        agentVersion: string;
+        capabilities: Readonly<{
+            additionalDirectories: boolean;
+            audioPrompt: boolean;
+            closeSession: boolean;
+            deleteSession: boolean;
+            embeddedContextPrompt: boolean;
+            imagePrompt: boolean;
+            listSessions: boolean;
+            loadSession: boolean;
+            promptQueueing: boolean;
+            resumeSession: boolean;
+            steering: boolean;
+            unstableForkSession: boolean;
+        }>;
+        commands: readonly Readonly<{
+            description: string;
+            inputHint: string;
+            name: string;
+        }>[];
+        configOptions: readonly Readonly<{
+            booleanValue: boolean;
+            category: string;
+            currentValue: string;
+            description: string;
+            id: string;
+            name: string;
+            type: "boolean" | "select";
+            values: readonly Readonly<{
+                description: string;
+                groupId: string;
+                groupName: string;
+                name: string;
+                value: string;
+            }>[];
+        }>[];
+        directoryId: string;
+        directoryLabel: string;
+        kind: "session.ready";
+        requestId: string;
+        restored: boolean;
+        runtimeTimings?: readonly Readonly<{
+            durationMilliseconds: number;
+            name: string;
+        }>[] | undefined;
+        sessionId: string;
+    }>>;
+    readonly "workspace.entries": MessageSignature<Readonly<{
+        bindingId: string;
+        directoryId: string;
+        directoryLabel: string;
+        entries: readonly Readonly<{
+            directoryId: string;
+            name: string;
+        }>[];
+        kind: "workspace.entries";
+        parentDirectoryId: string;
+        requestId: string;
+    }>>;
+};
+export type DaemonToServiceMessage = ReturnType<(typeof daemonToServiceSignatures)[keyof typeof daemonToServiceSignatures]["decoder"]>;
+export declare function decodeDaemonToServiceMessage(encoded: string): DaemonToServiceMessage;
+export declare function encodeDaemonToServiceMessage(message: DaemonToServiceMessage): string;
+export {};
+//# sourceMappingURL=daemon-transport.d.ts.map

package/dist/daemon-transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"daemon-transport.d.ts","sourceRoot":"","sources":["../src/daemon-transport.ts"],"names":[],"mappings":"AAmJA,UAAU,gBAAgB,CAAC,QAAQ,SAAS;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE;IACjE,QAAQ,CAAC,OAAO,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,QAAQ,CAAC;IAChD,QAAQ,CAAC,OAAO,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,MAAM,CAAC;IAC/C,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;IAChC,QAAQ,CAAC,MAAM,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,QAAQ,CAAC;CACnD;AAgBD,QAAA,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgHrB,CAAC;AAEX,MAAM,MAAM,sBAAsB,GAAG,UAAU,CAC3C,CAAC,OAAO,yBAAyB,CAAC,CAAC,MAAM,OAAO,yBAAyB,CAAC,CAAC,SAAS,CAAC,CACxF,CAAC;AAKF,wBAAgB,4BAA4B,CAAC,OAAO,EAAE,MAAM,GAAG,sBAAsB,CAOpF;AAED,wBAAgB,4BAA4B,CAAC,OAAO,EAAE,sBAAsB,GAAG,MAAM,CAEpF;AAED,QAAA,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsFrB,CAAC;AAEX,MAAM,MAAM,sBAAsB,GAAG,UAAU,CAC3C,CAAC,OAAO,yBAAyB,CAAC,CAAC,MAAM,OAAO,yBAAyB,CAAC,CAAC,SAAS,CAAC,CACxF,CAAC;AAKF,wBAAgB,4BAA4B,CAAC,OAAO,EAAE,MAAM,GAAG,sBAAsB,CAOpF;AAED,wBAAgB,4BAA4B,CAAC,OAAO,EAAE,sBAAsB,GAAG,MAAM,CAEpF"}

package/dist/daemon-transport.js

@@ -0,0 +1,88 @@
+import { decodeMessageKind, decodeRuntimeDelivery, decodeRuntimeDeliveryCommitted, decodeRuntimeDeliveryReceived, decodeRuntimeHeartbeatAckEvent, decodeRuntimeHeartbeatEvent, decodeRuntimeLivenessReadyEvent, decodeSessionCancelCommand, decodeSessionPromptCommand, encodeRuntimeDelivery, encodeRuntimeDeliveryCommitted, encodeRuntimeDeliveryReceived, encodeRuntimeHeartbeatAckEvent, encodeRuntimeHeartbeatEvent, encodeRuntimeLivenessReadyEvent, encodeSessionCancelCommand, encodeSessionPromptCommand, ProtocolMessageError, } from "./codecs/messages.js";
+import { AGENT_CATALOG_REFRESH_FAILED_KIND, AGENT_CATALOG_REFRESH_KIND, AGENT_CATALOG_REFRESHED_KIND, AGENT_INSTALL_CANCEL_KIND, AGENT_INSTALL_CANCELLED_KIND, AGENT_INSTALL_COMPLETED_KIND, AGENT_INSTALL_FAILED_KIND, AGENT_INSTALL_PROGRESS_KIND, AGENT_INSTALL_REQUEST_KIND, AGENT_INSTALL_STARTED_KIND, AGENT_SETTINGS_DISCOVER_KIND, AGENT_SETTINGS_DISCOVERED_KIND, AGENT_SETTINGS_DISCOVERY_FAILED_KIND, decodeAgentCatalogRefreshCommand, decodeAgentCatalogRefreshedEvent, decodeAgentCatalogRefreshFailedEvent, decodeAgentInstallCancelCommand, decodeAgentInstallCancelledEvent, decodeAgentInstallCompletedEvent, decodeAgentInstallFailedEvent, decodeAgentInstallProgressEvent, decodeAgentInstallRequestCommand, decodeAgentInstallStartedEvent, decodeAgentSettingsDiscoverCommand, decodeAgentSettingsDiscoveredEvent, decodeAgentSettingsDiscoveryFailedEvent, decodeFileBeginEvent, decodeFileChunkEvent, decodeFileEndEvent, decodeFileFailedEvent, decodeFileReadCommand, decodeSessionConfigureCommand, decodeSessionElicitationRespondCommand, decodeSessionOperationFailedEvent, decodeSessionPermissionRespondCommand, decodeSessionPrepareCommand, decodeSessionReadyEvent, decodeWorkspaceEntriesEvent, decodeWorkspaceListCommand, encodeAgentCatalogRefreshCommand, encodeAgentCatalogRefreshedEvent, encodeAgentCatalogRefreshFailedEvent, encodeAgentInstallCancelCommand, encodeAgentInstallCancelledEvent, encodeAgentInstallCompletedEvent, encodeAgentInstallFailedEvent, encodeAgentInstallProgressEvent, encodeAgentInstallRequestCommand, encodeAgentInstallStartedEvent, encodeAgentSettingsDiscoverCommand, encodeAgentSettingsDiscoveredEvent, encodeAgentSettingsDiscoveryFailedEvent, encodeFileBeginEvent, encodeFileChunkEvent, encodeFileEndEvent, encodeFileFailedEvent, encodeFileReadCommand, encodeSessionConfigureCommand, encodeSessionElicitationRespondCommand, encodeSessionOperationFailedEvent, encodeSessionPermissionRespondCommand, encodeSessionPrepareCommand, encodeSessionReadyEvent, encodeWorkspaceEntriesEvent, encodeWorkspaceListCommand, FILE_BEGIN_KIND, FILE_CHUNK_KIND, FILE_END_KIND, FILE_FAILED_KIND, FILE_READ_KIND, SESSION_CONFIGURE_KIND, SESSION_ELICITATION_RESPOND_KIND, SESSION_OPERATION_FAILED_KIND, SESSION_PERMISSION_RESPOND_KIND, SESSION_PREPARE_KIND, SESSION_READY_KIND, WORKSPACE_ENTRIES_KIND, WORKSPACE_LIST_KIND, } from "./control-messages.js";
+import { RUNTIME_DELIVERY_COMMITTED_KIND, RUNTIME_DELIVERY_KIND, RUNTIME_DELIVERY_RECEIVED_KIND, RUNTIME_HEARTBEAT_ACK_KIND, RUNTIME_HEARTBEAT_KIND, RUNTIME_LIVENESS_READY_KIND, SESSION_CANCEL_KIND, SESSION_PROMPT_KIND, } from "./messages.js";
+import { decodeNativeSessionCancel, decodeNativeSessionCommand, decodeNativeSessionResult, decodeNativeSessionTurnForkCommand, encodeNativeSessionCancel, encodeNativeSessionCommand, encodeNativeSessionResult, encodeNativeSessionTurnForkCommand, NATIVE_SESSION_CANCEL_KIND, NATIVE_SESSION_REQUEST_KIND, NATIVE_SESSION_RESULT_KIND, NATIVE_SESSION_TURN_FORK_KIND, } from "./native-sessions.js";
+import { decodeSessionEventAcknowledgement, decodeSessionEventDeferred, decodeSessionEventEnvelope, decodeSessionEventRejection, encodeSessionEventAcknowledgement, encodeSessionEventDeferred, encodeSessionEventEnvelope, encodeSessionEventRejection, SESSION_EVENT_ACK_KIND, SESSION_EVENT_DEFERRED_KIND, SESSION_EVENT_KIND, SESSION_EVENT_REJECTED_KIND, } from "./session-events.js";
+import { decodeSessionLiveHistoryLoad, decodeSessionLiveHistoryLoaded, encodeSessionLiveHistoryLoad, encodeSessionLiveHistoryLoaded, SESSION_LIVE_HISTORY_LOAD_KIND, SESSION_LIVE_HISTORY_LOADED_KIND, } from "./session-live-history.js";
+function defineMessageSignature(kind, encoder, decoder) {
+    const schema = (message) => decoder(JSON.stringify(message));
+    return {
+        decoder,
+        encoder: (message) => encoder(schema(message)),
+        kind,
+        schema,
+    };
+}
+const serviceToDaemonSignatures = {
+    [AGENT_CATALOG_REFRESH_KIND]: defineMessageSignature(AGENT_CATALOG_REFRESH_KIND, encodeAgentCatalogRefreshCommand, decodeAgentCatalogRefreshCommand),
+    [AGENT_INSTALL_CANCEL_KIND]: defineMessageSignature(AGENT_INSTALL_CANCEL_KIND, encodeAgentInstallCancelCommand, decodeAgentInstallCancelCommand),
+    [AGENT_INSTALL_REQUEST_KIND]: defineMessageSignature(AGENT_INSTALL_REQUEST_KIND, encodeAgentInstallRequestCommand, decodeAgentInstallRequestCommand),
+    [AGENT_SETTINGS_DISCOVER_KIND]: defineMessageSignature(AGENT_SETTINGS_DISCOVER_KIND, encodeAgentSettingsDiscoverCommand, decodeAgentSettingsDiscoverCommand),
+    [FILE_READ_KIND]: defineMessageSignature(FILE_READ_KIND, encodeFileReadCommand, decodeFileReadCommand),
+    [NATIVE_SESSION_CANCEL_KIND]: defineMessageSignature(NATIVE_SESSION_CANCEL_KIND, encodeNativeSessionCancel, decodeNativeSessionCancel),
+    [NATIVE_SESSION_REQUEST_KIND]: defineMessageSignature(NATIVE_SESSION_REQUEST_KIND, encodeNativeSessionCommand, decodeNativeSessionCommand),
+    [NATIVE_SESSION_TURN_FORK_KIND]: defineMessageSignature(NATIVE_SESSION_TURN_FORK_KIND, encodeNativeSessionTurnForkCommand, decodeNativeSessionTurnForkCommand),
+    [RUNTIME_DELIVERY_KIND]: defineMessageSignature(RUNTIME_DELIVERY_KIND, encodeRuntimeDelivery, decodeRuntimeDelivery),
+    [RUNTIME_DELIVERY_COMMITTED_KIND]: defineMessageSignature(RUNTIME_DELIVERY_COMMITTED_KIND, encodeRuntimeDeliveryCommitted, decodeRuntimeDeliveryCommitted),
+    [RUNTIME_HEARTBEAT_ACK_KIND]: defineMessageSignature(RUNTIME_HEARTBEAT_ACK_KIND, encodeRuntimeHeartbeatAckEvent, decodeRuntimeHeartbeatAckEvent),
+    [RUNTIME_LIVENESS_READY_KIND]: defineMessageSignature(RUNTIME_LIVENESS_READY_KIND, encodeRuntimeLivenessReadyEvent, decodeRuntimeLivenessReadyEvent),
+    [SESSION_CANCEL_KIND]: defineMessageSignature(SESSION_CANCEL_KIND, encodeSessionCancelCommand, decodeSessionCancelCommand),
+    [SESSION_CONFIGURE_KIND]: defineMessageSignature(SESSION_CONFIGURE_KIND, encodeSessionConfigureCommand, decodeSessionConfigureCommand),
+    [SESSION_ELICITATION_RESPOND_KIND]: defineMessageSignature(SESSION_ELICITATION_RESPOND_KIND, encodeSessionElicitationRespondCommand, decodeSessionElicitationRespondCommand),
+    [SESSION_EVENT_ACK_KIND]: defineMessageSignature(SESSION_EVENT_ACK_KIND, encodeSessionEventAcknowledgement, decodeSessionEventAcknowledgement),
+    [SESSION_EVENT_DEFERRED_KIND]: defineMessageSignature(SESSION_EVENT_DEFERRED_KIND, encodeSessionEventDeferred, decodeSessionEventDeferred),
+    [SESSION_EVENT_REJECTED_KIND]: defineMessageSignature(SESSION_EVENT_REJECTED_KIND, encodeSessionEventRejection, decodeSessionEventRejection),
+    [SESSION_LIVE_HISTORY_LOAD_KIND]: defineMessageSignature(SESSION_LIVE_HISTORY_LOAD_KIND, encodeSessionLiveHistoryLoad, decodeSessionLiveHistoryLoad),
+    [SESSION_PERMISSION_RESPOND_KIND]: defineMessageSignature(SESSION_PERMISSION_RESPOND_KIND, encodeSessionPermissionRespondCommand, decodeSessionPermissionRespondCommand),
+    [SESSION_PREPARE_KIND]: defineMessageSignature(SESSION_PREPARE_KIND, encodeSessionPrepareCommand, decodeSessionPrepareCommand),
+    [SESSION_PROMPT_KIND]: defineMessageSignature(SESSION_PROMPT_KIND, encodeSessionPromptCommand, decodeSessionPromptCommand),
+    [WORKSPACE_LIST_KIND]: defineMessageSignature(WORKSPACE_LIST_KIND, encodeWorkspaceListCommand, decodeWorkspaceListCommand),
+};
+const serviceToDaemonRegistry = serviceToDaemonSignatures;
+export function decodeServiceToDaemonMessage(encoded) {
+    const kind = decodeMessageKind(encoded);
+    const signature = serviceToDaemonRegistry[kind];
+    if (signature === undefined) {
+        throw new ProtocolMessageError(`Unsupported service-to-daemon message kind: ${kind}`);
+    }
+    return signature.decoder(encoded);
+}
+export function encodeServiceToDaemonMessage(message) {
+    return serviceToDaemonSignatures[message.kind].encoder(message);
+}
+const daemonToServiceSignatures = {
+    [AGENT_CATALOG_REFRESHED_KIND]: defineMessageSignature(AGENT_CATALOG_REFRESHED_KIND, encodeAgentCatalogRefreshedEvent, decodeAgentCatalogRefreshedEvent),
+    [AGENT_CATALOG_REFRESH_FAILED_KIND]: defineMessageSignature(AGENT_CATALOG_REFRESH_FAILED_KIND, encodeAgentCatalogRefreshFailedEvent, decodeAgentCatalogRefreshFailedEvent),
+    [AGENT_INSTALL_CANCELLED_KIND]: defineMessageSignature(AGENT_INSTALL_CANCELLED_KIND, encodeAgentInstallCancelledEvent, decodeAgentInstallCancelledEvent),
+    [AGENT_INSTALL_COMPLETED_KIND]: defineMessageSignature(AGENT_INSTALL_COMPLETED_KIND, encodeAgentInstallCompletedEvent, decodeAgentInstallCompletedEvent),
+    [AGENT_INSTALL_FAILED_KIND]: defineMessageSignature(AGENT_INSTALL_FAILED_KIND, encodeAgentInstallFailedEvent, decodeAgentInstallFailedEvent),
+    [AGENT_INSTALL_PROGRESS_KIND]: defineMessageSignature(AGENT_INSTALL_PROGRESS_KIND, encodeAgentInstallProgressEvent, decodeAgentInstallProgressEvent),
+    [AGENT_INSTALL_STARTED_KIND]: defineMessageSignature(AGENT_INSTALL_STARTED_KIND, encodeAgentInstallStartedEvent, decodeAgentInstallStartedEvent),
+    [AGENT_SETTINGS_DISCOVERED_KIND]: defineMessageSignature(AGENT_SETTINGS_DISCOVERED_KIND, encodeAgentSettingsDiscoveredEvent, decodeAgentSettingsDiscoveredEvent),
+    [AGENT_SETTINGS_DISCOVERY_FAILED_KIND]: defineMessageSignature(AGENT_SETTINGS_DISCOVERY_FAILED_KIND, encodeAgentSettingsDiscoveryFailedEvent, decodeAgentSettingsDiscoveryFailedEvent),
+    [FILE_BEGIN_KIND]: defineMessageSignature(FILE_BEGIN_KIND, encodeFileBeginEvent, decodeFileBeginEvent),
+    [FILE_CHUNK_KIND]: defineMessageSignature(FILE_CHUNK_KIND, encodeFileChunkEvent, decodeFileChunkEvent),
+    [FILE_END_KIND]: defineMessageSignature(FILE_END_KIND, encodeFileEndEvent, decodeFileEndEvent),
+    [FILE_FAILED_KIND]: defineMessageSignature(FILE_FAILED_KIND, encodeFileFailedEvent, decodeFileFailedEvent),
+    [NATIVE_SESSION_RESULT_KIND]: defineMessageSignature(NATIVE_SESSION_RESULT_KIND, encodeNativeSessionResult, decodeNativeSessionResult),
+    [RUNTIME_DELIVERY_RECEIVED_KIND]: defineMessageSignature(RUNTIME_DELIVERY_RECEIVED_KIND, encodeRuntimeDeliveryReceived, decodeRuntimeDeliveryReceived),
+    [RUNTIME_HEARTBEAT_KIND]: defineMessageSignature(RUNTIME_HEARTBEAT_KIND, encodeRuntimeHeartbeatEvent, decodeRuntimeHeartbeatEvent),
+    [SESSION_EVENT_KIND]: defineMessageSignature(SESSION_EVENT_KIND, encodeSessionEventEnvelope, decodeSessionEventEnvelope),
+    [SESSION_OPERATION_FAILED_KIND]: defineMessageSignature(SESSION_OPERATION_FAILED_KIND, encodeSessionOperationFailedEvent, decodeSessionOperationFailedEvent),
+    [SESSION_LIVE_HISTORY_LOADED_KIND]: defineMessageSignature(SESSION_LIVE_HISTORY_LOADED_KIND, encodeSessionLiveHistoryLoaded, decodeSessionLiveHistoryLoaded),
+    [SESSION_READY_KIND]: defineMessageSignature(SESSION_READY_KIND, encodeSessionReadyEvent, decodeSessionReadyEvent),
+    [WORKSPACE_ENTRIES_KIND]: defineMessageSignature(WORKSPACE_ENTRIES_KIND, encodeWorkspaceEntriesEvent, decodeWorkspaceEntriesEvent),
+};
+const daemonToServiceRegistry = daemonToServiceSignatures;
+export function decodeDaemonToServiceMessage(encoded) {
+    const kind = decodeMessageKind(encoded);
+    const signature = daemonToServiceRegistry[kind];
+    if (signature === undefined) {
+        throw new ProtocolMessageError(`Unsupported daemon-to-service message kind: ${kind}`);
+    }
+    return signature.decoder(encoded);
+}
+export function encodeDaemonToServiceMessage(message) {
+    return daemonToServiceSignatures[message.kind].encoder(message);
+}
+//# sourceMappingURL=daemon-transport.js.map