@maiaos/sdk 0.1.0-canary.2

package/dist/voice/orchestrator.js

@@ -0,0 +1,169 @@
+import { MAIA_PROTOCOL_VERSION, protocolErrorEnvelopeSchema, protocolIdentifierSchema, protocolRequestEnvelopeSchema, protocolSuccessEnvelopeSchema, } from "@maiaos/protocol";
+import { MAX_VOICE_ORCHESTRATOR_CONTEXT_BYTES, MAX_VOICE_ORCHESTRATOR_SAFE_MESSAGE_BYTES, MAX_VOICE_ORCHESTRATOR_TOOL_OUTPUT_BYTES, MAX_VOICE_ORCHESTRATOR_TOOL_REQUEST_BYTES, } from "@maiaos/protocol/voice-orchestrator";
+import { voiceWire } from "./wire-schema.js";
+export class VoiceOrchestratorClientError extends Error {
+    code;
+    remoteError;
+    constructor(code, message, options) {
+        super(message, options);
+        this.name = "VoiceOrchestratorClientError";
+        this.code = code;
+        this.remoteError = options?.remoteError;
+    }
+}
+const utf8 = new TextEncoder();
+const objectWithin = (value, maximumBytes) => {
+    try {
+        const encoded = JSON.stringify(value);
+        return (encoded !== undefined && utf8.encode(encoded).byteLength <= maximumBytes);
+    }
+    catch {
+        return false;
+    }
+};
+const invalidRequest = (message, error) => {
+    throw new VoiceOrchestratorClientError("invalid_request", message, {
+        ...(error === undefined ? {} : { cause: error }),
+    });
+};
+const invalidResponse = (message, error) => {
+    throw new VoiceOrchestratorClientError("invalid_response", message, {
+        ...(error === undefined ? {} : { cause: error }),
+    });
+};
+const validateContextParameters = (parameters) => {
+    try {
+        return voiceWire.orchestratorContextParameters(parameters);
+    }
+    catch (error) {
+        return invalidRequest("The voice orchestrator context input is invalid.", error);
+    }
+};
+const validateToolParameters = (parameters) => {
+    if (!objectWithin(parameters, MAX_VOICE_ORCHESTRATOR_TOOL_REQUEST_BYTES)) {
+        return invalidRequest("The voice orchestrator tool input is invalid.");
+    }
+    try {
+        const validated = voiceWire.orchestratorToolParameters(parameters);
+        voiceWire.toolCall(validated.call);
+        return validated;
+    }
+    catch (error) {
+        return invalidRequest("The voice orchestrator tool input is invalid.", error);
+    }
+};
+const parseRequestEnvelope = (messageId, payload) => {
+    try {
+        protocolIdentifierSchema.parse(messageId);
+        return protocolRequestEnvelopeSchema.parse({
+            kind: "request",
+            messageId,
+            payload,
+            protocolVersion: MAIA_PROTOCOL_VERSION,
+        });
+    }
+    catch (error) {
+        return invalidRequest("The Maia voice orchestrator request failed runtime validation.", error);
+    }
+};
+const requestTransport = async (transport, envelope, signal) => {
+    if (signal?.aborted === true) {
+        throw new VoiceOrchestratorClientError("cancelled", "The Maia voice orchestrator request was cancelled.");
+    }
+    try {
+        return await transport.request(envelope, signal === undefined ? undefined : { signal });
+    }
+    catch (error) {
+        if (error instanceof VoiceOrchestratorClientError)
+            throw error;
+        const cancelled = signal?.aborted ?? false;
+        throw new VoiceOrchestratorClientError(cancelled ? "cancelled" : "transport_failure", cancelled
+            ? "The Maia voice orchestrator request was cancelled."
+            : "The Maia voice orchestrator transport request failed.", { cause: error });
+    }
+};
+const remoteErrorCode = (code) => code === "deadline_exceeded" ||
+    code === "outcome_unknown" ||
+    code === "saturated"
+    ? code
+    : "remote_error";
+const rejectRemoteError = (rawResponse, messageId) => {
+    const remote = protocolErrorEnvelopeSchema.safeParse(rawResponse);
+    if (!remote.success)
+        return;
+    if (remote.data.correlationId !== messageId) {
+        throw new VoiceOrchestratorClientError("correlation_mismatch", "The Maia voice orchestrator response did not match the request.");
+    }
+    throw new VoiceOrchestratorClientError(remoteErrorCode(remote.data.payload.error.code), remote.data.payload.error.message, { remoteError: remote.data.payload.error });
+};
+const parsePayload = (rawResponse, messageId) => {
+    rejectRemoteError(rawResponse, messageId);
+    try {
+        const response = protocolSuccessEnvelopeSchema.parse(rawResponse);
+        if (response.correlationId !== messageId) {
+            throw new VoiceOrchestratorClientError("correlation_mismatch", "The Maia voice orchestrator response did not match the request.");
+        }
+        return response.payload.result;
+    }
+    catch (error) {
+        if (error instanceof VoiceOrchestratorClientError)
+            throw error;
+        return invalidResponse("The Maia voice orchestrator response envelope is invalid.", error);
+    }
+};
+const parseContextResult = (raw) => {
+    if (!objectWithin(raw, MAX_VOICE_ORCHESTRATOR_CONTEXT_BYTES)) {
+        return invalidResponse("The voice orchestrator context output is invalid.");
+    }
+    try {
+        return voiceWire.orchestratorContextResult(raw);
+    }
+    catch (error) {
+        return invalidResponse("The voice orchestrator context output is invalid.", error);
+    }
+};
+const parseToolResult = (raw) => {
+    if (!objectWithin(raw, MAX_VOICE_ORCHESTRATOR_TOOL_OUTPUT_BYTES)) {
+        return invalidResponse("The voice orchestrator tool output is invalid.");
+    }
+    try {
+        const result = voiceWire.orchestratorToolResult(raw);
+        if (result.modelResult.status === "rejected" &&
+            utf8.encode(result.modelResult.error.message).byteLength >
+                MAX_VOICE_ORCHESTRATOR_SAFE_MESSAGE_BYTES) {
+            return invalidResponse("The voice orchestrator tool output is invalid.");
+        }
+        return result;
+    }
+    catch (error) {
+        return invalidResponse("The voice orchestrator tool output is invalid.", error);
+    }
+};
+const request = async (transport, input) => {
+    const { options, parse, payload } = input;
+    const envelope = parseRequestEnvelope(options.messageId, payload);
+    const raw = await requestTransport(transport, envelope, options.signal);
+    return parse(parsePayload(raw, options.messageId));
+};
+export const createVoiceOrchestratorClient = (transport) => ({
+    callVoiceOrchestratorTool: async (rawParameters, options) => {
+        const parameters = validateToolParameters(rawParameters);
+        const result = await request(transport, {
+            options,
+            parse: parseToolResult,
+            payload: { method: "voice.orchestrator.tool.call", parameters },
+        });
+        return result.scopeId === parameters.scopeId
+            ? result
+            : invalidResponse("The voice orchestrator response did not match the request.");
+    },
+    showVoiceOrchestratorContext: (rawParameters, options) => {
+        const parameters = validateContextParameters(rawParameters);
+        return request(transport, {
+            options,
+            parse: parseContextResult,
+            payload: { method: "voice.orchestrator.context.show", parameters },
+        });
+    },
+});
+//# sourceMappingURL=orchestrator.js.map

package/dist/voice/pi-relay-contract.d.ts

@@ -0,0 +1,4 @@
+export type { MaiaTransport } from "../request/index.js";
+export { createVoicePiRelayClient, type VoicePiRelayClient, } from "./pi-relay.js";
+export type { VoicePiRelayParameters, VoicePiRelayPreviewParameters, VoicePiRelayPreviewResult, VoicePiRelayReconcileParameters, VoicePiRelayReconcileResult, VoicePiRelayResult, } from "@maiaos/protocol/voice-pi-relay";
+//# sourceMappingURL=pi-relay-contract.d.ts.map

package/dist/voice/pi-relay-contract.js

@@ -0,0 +1,2 @@
+export { createVoicePiRelayClient, } from "./pi-relay.js";
+//# sourceMappingURL=pi-relay-contract.js.map

package/dist/voice/pi-relay.d.ts

@@ -0,0 +1,12 @@
+import type { VoicePiRelayParameters, VoicePiRelayPreviewParameters, VoicePiRelayPreviewResult, VoicePiRelayReconcileParameters, VoicePiRelayReconcileResult, VoicePiRelayResult } from "@maiaos/protocol/voice-pi-relay";
+import type { LocalNodeRequester, LocalNodeRequestOptions } from "../request/index.js";
+import { type MaiaTransport } from "../request/index.js";
+export type VoicePiRelayClient = {
+    readonly previewVoiceToPi: (parameters: VoicePiRelayPreviewParameters, options: LocalNodeRequestOptions) => Promise<VoicePiRelayPreviewResult>;
+    readonly reconcileVoiceToPi: (parameters: VoicePiRelayReconcileParameters, options: LocalNodeRequestOptions) => Promise<VoicePiRelayReconcileResult>;
+    readonly relayVoiceToPi: (parameters: VoicePiRelayParameters, options: LocalNodeRequestOptions) => Promise<VoicePiRelayResult>;
+};
+export type InvalidVoicePiRelayResponse = () => never;
+export declare const makeVoicePiRelayClient: (request: LocalNodeRequester, invalidResponse: InvalidVoicePiRelayResponse) => VoicePiRelayClient;
+export declare const createVoicePiRelayClient: (transport: MaiaTransport) => VoicePiRelayClient;
+//# sourceMappingURL=pi-relay.d.ts.map

package/dist/voice/pi-relay.js

@@ -0,0 +1,9 @@
+import { fromPromiseRequester, fromPromiseTransport, makeLocalNodeEffectRequester, toPromiseClient, } from "../request/effect.js";
+import { MaiaClientError } from "../request/index.js";
+import { makeVoicePiRelayOperations } from "./effect.js";
+export const makeVoicePiRelayClient = (request, invalidResponse) => toPromiseClient(makeVoicePiRelayOperations(fromPromiseRequester(request), invalidResponse));
+const invalidVoicePiRelayResponse = () => {
+    throw new MaiaClientError("invalid_response", "The Pi voice relay response did not match the request.");
+};
+export const createVoicePiRelayClient = (transport) => toPromiseClient(makeVoicePiRelayOperations(makeLocalNodeEffectRequester(fromPromiseTransport(transport), false), invalidVoicePiRelayResponse));
+//# sourceMappingURL=pi-relay.js.map

package/dist/voice/wire-schema.d.ts

@@ -0,0 +1,215 @@
+export declare const voiceWire: {
+    readonly orchestratorContextParameters: (input: unknown) => Readonly<Record<string, never>>;
+    readonly orchestratorContextResult: (input: unknown) => {
+        readonly method: "voice.orchestrator.context.show";
+        readonly releaseQualified: false;
+        readonly schemaVersion: "maia.voice-orchestrator-context/v1";
+        readonly scope: {
+            readonly contextRevision: string;
+            readonly id: string;
+            readonly workspaceId: string;
+            readonly workspaceRevision: string;
+        };
+        readonly systemPrompt: string;
+        readonly systemPromptSha256: string;
+        readonly systemPromptVersion: number;
+        readonly tools: readonly [{
+            readonly description: "Route one bounded Maia voice action through the authoritative Maia Node. ask prepares an exact Pi message for trusted on-screen confirmation; status reads one current bounded Node snapshot.";
+            readonly name: "maia";
+            readonly parameters: {
+                readonly [x: string]: unknown;
+            };
+            readonly type: "function";
+        }];
+    };
+    readonly orchestratorToolParameters: (input: unknown) => {
+        readonly call: unknown;
+        readonly scopeId: string;
+    };
+    readonly orchestratorToolResult: (input: unknown) => {
+        readonly interaction: {
+            readonly body: string;
+            readonly confirmation: {
+                readonly commandId: string;
+                readonly contextRevision: string;
+                readonly expiresAt: string;
+                readonly releaseQualified: false;
+                readonly schemaVersion: 2;
+                readonly sessionId: string;
+                readonly workspaceId: string;
+                readonly workspaceRevision: string;
+                readonly method: "voice.pi.relay.preview";
+                readonly proof: string;
+            };
+            readonly kind: "confirmation-required";
+        } | null;
+        readonly method: "voice.orchestrator.tool.call";
+        readonly modelResult: {
+            readonly action: "status";
+            readonly authority: "managed-maia-agent";
+            readonly data: {
+                readonly status: "no-managed-turn" | "unknown";
+            } | {
+                readonly result: {
+                    readonly phase: "completed" | "dispatching" | "failed" | "interrupted" | "outcome-unknown" | "queued" | "running";
+                    readonly reason?: string | undefined;
+                    readonly text?: string | undefined;
+                    readonly truncated: boolean;
+                };
+                readonly sessionId: string;
+                readonly status: "ok";
+                readonly turnId: string;
+            };
+            readonly error: null;
+            readonly interaction: null;
+            readonly receipt: null;
+            readonly releaseQualified: false;
+            readonly schemaVersion: "maia.voice-managed-status-result/v1";
+            readonly status: "managed-status";
+        } | {
+            readonly action: "ask";
+            readonly authority: "managed-maia-agent";
+            readonly error: null;
+            readonly interaction: {
+                readonly applyMethod: "voice.managed-turn.confirm";
+                readonly commandId: string;
+                readonly expectedSessionRevision: string;
+                readonly expiresAt: string;
+                readonly requiresTrustedGesture: true;
+                readonly sessionId: string;
+            };
+            readonly receipt: null;
+            readonly releaseQualified: false;
+            readonly schemaVersion: "maia.voice-managed-preview-result/v1";
+            readonly status: "awaiting-confirmation";
+        } | {
+            readonly releaseQualified: false;
+            readonly schemaVersion: "maia.voice-tool-result/v1";
+            readonly action: "ask";
+            readonly error: null;
+            readonly interaction: {
+                readonly applyMethod: "voice.pi.relay";
+                readonly kind: "confirmation-required";
+                readonly previewId: string;
+                readonly requiresTrustedGesture: true;
+            };
+            readonly receipt: null;
+            readonly status: "confirmation-required";
+        } | {
+            readonly releaseQualified: false;
+            readonly schemaVersion: "maia.voice-tool-result/v1";
+            readonly action: "status";
+            readonly data: {
+                readonly lifecycle: "draining" | "failed" | "ready" | "starting" | "stopped";
+                readonly method: "node.status";
+                readonly processResources: {
+                    readonly activeTrees: number;
+                    readonly admissionState: "available" | "degraded" | "pressured" | "saturated" | "unavailable";
+                    readonly cleanupUnknownTrees: number;
+                    readonly nextStep: "close_idle_terminal" | "inspect_cleanup_unknown" | "inspect_observed_pressure" | "none" | "verify_native_host";
+                    readonly pressure: "admission_degraded" | "cleanup_unknown" | "healthy" | "observed_pressure" | "warning";
+                };
+                readonly storageIntegrity: "ok";
+            };
+            readonly error: null;
+            readonly interaction: null;
+            readonly receipt: null;
+            readonly status: "ok";
+        } | {
+            readonly releaseQualified: false;
+            readonly schemaVersion: "maia.voice-tool-result/v1";
+            readonly action: "ask" | "status" | "unknown";
+            readonly error: {
+                readonly code: "bridge_unavailable" | "call_conflict" | "capacity_exceeded" | "invalid_input" | "scope_stale";
+                readonly message: string;
+            };
+            readonly interaction: null;
+            readonly receipt: null;
+            readonly status: "rejected";
+        };
+        readonly releaseQualified: false;
+        readonly schemaVersion: "maia.voice-orchestrator-call/v1";
+        readonly scopeId: string;
+    };
+    readonly previewParameters: (input: unknown) => {
+        readonly body: string;
+        readonly commandId: string;
+        readonly expectedContextRevision: string;
+        readonly expectedWorkspaceRevision: string;
+        readonly workspaceId: string;
+    };
+    readonly previewResult: (input: unknown) => {
+        readonly commandId: string;
+        readonly contextRevision: string;
+        readonly expiresAt: string;
+        readonly releaseQualified: false;
+        readonly schemaVersion: 2;
+        readonly sessionId: string;
+        readonly workspaceId: string;
+        readonly workspaceRevision: string;
+        readonly method: "voice.pi.relay.preview";
+        readonly proof: string;
+    };
+    readonly reconcileParameters: (input: unknown) => {
+        readonly commandId: string;
+    };
+    readonly reconcileResult: (input: unknown) => {
+        readonly commandId: string;
+        readonly contextRevision: string;
+        readonly expiresAt: string;
+        readonly releaseQualified: false;
+        readonly schemaVersion: 2;
+        readonly sessionId: string;
+        readonly workspaceId: string;
+        readonly workspaceRevision: string;
+        readonly method: "voice.pi.relay.reconcile";
+        readonly state: "acknowledged" | "dispatching" | "expired" | "outcome-unknown" | "prepared" | "previewed";
+    };
+    readonly relayParameters: (input: unknown) => {
+        readonly body: string;
+        readonly commandId: string;
+        readonly expectedContextRevision: string;
+        readonly expectedWorkspaceRevision: string;
+        readonly workspaceId: string;
+        readonly proof: string;
+        readonly sessionId: string;
+    };
+    readonly relayResult: (input: unknown) => {
+        readonly commandId: string;
+        readonly contextRevision: string;
+        readonly delivery: "duplicate" | "new";
+        readonly method: "voice.pi.relay";
+        readonly receipt: {
+            readonly actorId: string;
+            readonly aggregateRevision: string;
+            readonly commandId: string;
+            readonly createdAt: string;
+            readonly eventCursor: string;
+            readonly method: string;
+            readonly receiptId: string;
+            readonly schemaVersion: 1;
+            readonly state: "succeeded";
+            readonly target: {
+                readonly id: string;
+                readonly type: string;
+            };
+            readonly updatedAt: string;
+        };
+        readonly releaseQualified: false;
+        readonly schemaVersion: 2;
+        readonly sessionId: string;
+        readonly workspaceId: string;
+        readonly workspaceRevision: string;
+    };
+    readonly toolCall: (input: unknown) => {
+        readonly args: {
+            readonly action: "ask";
+            readonly utterance: string;
+        } | {
+            readonly action: "status";
+        };
+        readonly toolCallId: string;
+        readonly toolName: "maia";
+    };
+};
+//# sourceMappingURL=wire-schema.d.ts.map

package/dist/voice/wire-schema.js

@@ -0,0 +1,16 @@
+import { voiceOrchestratorContextShowParametersSchema, voiceOrchestratorContextShowResultSchema, voiceOrchestratorToolCallParametersSchema, voiceOrchestratorToolCallResultSchema, voiceOrchestratorToolCallSchema, } from "@maiaos/protocol/voice-orchestrator";
+import { voicePiRelayParametersSchema, voicePiRelayPreviewParametersSchema, voicePiRelayPreviewResultSchema, voicePiRelayReconcileParametersSchema, voicePiRelayReconcileResultSchema, voicePiRelayResultSchema, } from "@maiaos/protocol/voice-pi-relay";
+export const voiceWire = {
+    orchestratorContextParameters: voiceOrchestratorContextShowParametersSchema.parse,
+    orchestratorContextResult: voiceOrchestratorContextShowResultSchema.parse,
+    orchestratorToolParameters: voiceOrchestratorToolCallParametersSchema.parse,
+    orchestratorToolResult: voiceOrchestratorToolCallResultSchema.parse,
+    previewParameters: voicePiRelayPreviewParametersSchema.parse,
+    previewResult: voicePiRelayPreviewResultSchema.parse,
+    reconcileParameters: voicePiRelayReconcileParametersSchema.parse,
+    reconcileResult: voicePiRelayReconcileResultSchema.parse,
+    relayParameters: voicePiRelayParametersSchema.parse,
+    relayResult: voicePiRelayResultSchema.parse,
+    toolCall: voiceOrchestratorToolCallSchema.parse,
+};
+//# sourceMappingURL=wire-schema.js.map

package/package.json

@@ -0,0 +1,84 @@
+{
+  "name": "@maiaos/sdk",
+  "version": "0.1.0-canary.2",
+  "description": "TypeScript SDK for Maia Node: typed, validated calls to create and drive AI coding agent Sessions (Claude Code, Codex), wait for turns and read receipts.",
+  "keywords": [
+    "maia",
+    "maiaos",
+    "ai-agents",
+    "coding-agents",
+    "multi-agent",
+    "agent-orchestration",
+    "sdk",
+    "typescript",
+    "claude-code",
+    "codex",
+    "effect"
+  ],
+  "homepage": "https://github.com/maiaos/maiaos/tree/main/packages/sdk#readme",
+  "bugs": "https://github.com/maiaos/maiaos/issues",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/maiaos/maiaos.git",
+    "directory": "packages/sdk"
+  },
+  "type": "module",
+  "sideEffects": false,
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./node": {
+      "types": "./dist/node/index.d.ts",
+      "import": "./dist/node/index.js",
+      "default": "./dist/node/index.js"
+    },
+    "./node/effect": {
+      "types": "./dist/node/effect.d.ts",
+      "import": "./dist/node/effect.js",
+      "default": "./dist/node/effect.js"
+    },
+    "./voice-orchestrator": {
+      "types": "./dist/voice/orchestrator-contract.d.ts",
+      "import": "./dist/voice/orchestrator-contract.js",
+      "default": "./dist/voice/orchestrator-contract.js"
+    },
+    "./voice-pi-relay": {
+      "types": "./dist/voice/pi-relay-contract.d.ts",
+      "import": "./dist/voice/pi-relay-contract.js",
+      "default": "./dist/voice/pi-relay-contract.js"
+    }
+  },
+  "files": [
+    "dist",
+    "!dist/**/*.d.ts.map",
+    "!dist/**/*.js.map",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": "24.22.1"
+  },
+  "devDependencies": {
+    "@types/node": "24.13.3",
+    "@typescript/native": "npm:typescript@7.0.2",
+    "@vllnt/typescript": "2.0.0-canary.a1749e0",
+    "eslint": "9.39.5",
+    "typescript": "npm:@typescript/typescript6@6.0.2"
+  },
+  "dependencies": {
+    "@maiaos/protocol": "0.1.0-canary.2",
+    "effect": "4.0.0"
+  },
+  "scripts": {
+    "build": "node -e \"require('node:fs').rmSync('dist',{force:true,recursive:true})\" && tsc --project tsconfig.build.json",
+    "lint": "eslint src --max-warnings 0",
+    "test": "node -e \"require('node:fs').rmSync('.test-dist',{force:true,recursive:true})\" && tsc --project tsconfig.test.json && node --import ../../scripts/lib/test-environment.mjs --test --test-concurrency=2 --enable-source-maps \".test-dist/**/*.test.js\"",
+    "typecheck": "tsc --project tsconfig.json --noEmit"
+  }
+}