@maiaos/sdk 0.1.0-canary.2

package/dist/session-creation/tasks.js

@@ -0,0 +1,37 @@
+import { MAX_TURN_INPUT_BYTES, } from "@maiaos/protocol";
+export const MAX_SESSION_CREATION_TASKS = 32;
+export const orderExecutionWorkspaces = (workspaces) => workspaces
+    .filter((workspace) => workspace.state === "ready")
+    .toSorted((left, right) => Number(right.kind === "local-main") -
+    Number(left.kind === "local-main") ||
+    left.name.localeCompare(right.name));
+const utf8 = new TextEncoder();
+const taskLines = (input) => {
+    if (input.split === "whole") {
+        const task = input.text.trim();
+        return [{ line: 1, ...(task === "" ? {} : { task }) }];
+    }
+    return input.text
+        .split(/\r?\n/u)
+        .map((text, index) => ({ line: index + 1, task: text.trim() }))
+        .filter((entry) => entry.task !== "");
+};
+const fits = (entry) => entry.task === undefined ||
+    utf8.encode(entry.task).byteLength <= MAX_TURN_INPUT_BYTES;
+export const splitTasks = (input) => {
+    const lines = taskLines(input);
+    const fitting = lines.filter((entry) => fits(entry));
+    const refusals = [
+        ...lines
+            .filter((entry) => !fits(entry))
+            .map((entry) => ({ line: entry.line, reason: "too_long" })),
+        ...fitting.slice(MAX_SESSION_CREATION_TASKS).map((entry) => ({
+            line: entry.line,
+            reason: "over_batch_limit",
+        })),
+    ].toSorted((left, right) => left.line - right.line);
+    return { accepted: fitting.slice(0, MAX_SESSION_CREATION_TASKS), refusals };
+};
+export const sessionCreationSettled = (outcome, item) => outcome.stage === "sent" ||
+    (outcome.stage === "started" && item.task === undefined);
+//# sourceMappingURL=tasks.js.map

package/dist/session-view/index.d.ts

@@ -0,0 +1,2 @@
+export { initialSessionAttachView, isNewSessionRecord, MAX_SESSION_VIEW_TURN_ITEMS, MAX_SESSION_VIEW_TURNS, reduceSessionAttach, sessionAttachCursor, type SessionAttachView, sessionItemText, type SessionViewEnd, type SessionViewItem, type SessionViewTurn, } from "./view.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/session-view/index.js

@@ -0,0 +1,2 @@
+export { initialSessionAttachView, isNewSessionRecord, MAX_SESSION_VIEW_TURN_ITEMS, MAX_SESSION_VIEW_TURNS, reduceSessionAttach, sessionAttachCursor, sessionItemText, } from "./view.js";
+//# sourceMappingURL=index.js.map

package/dist/session-view/view.d.ts

@@ -0,0 +1,42 @@
+import type { FailureDetail, SessionAttachFrame, SessionItem, SessionItemStatus, SessionStreamRecord, SessionTurnStatus } from "@maiaos/protocol";
+export declare const MAX_SESSION_VIEW_TURNS = 64;
+export declare const MAX_SESSION_VIEW_TURN_ITEMS = 256;
+export type SessionViewItem = {
+    readonly item: SessionItem;
+    readonly itemId: string;
+    readonly sequence: number;
+    readonly status: "open" | SessionItemStatus;
+    readonly text: string;
+    readonly truncated: boolean;
+};
+export type SessionViewTurn = {
+    readonly failure?: FailureDetail;
+    readonly items: readonly SessionViewItem[];
+    readonly status: "running" | SessionTurnStatus;
+    readonly turnId: string;
+};
+export type SessionViewEnd = {
+    readonly code: string;
+    readonly kind: "error";
+    readonly message: string;
+} | {
+    readonly kind: "resync";
+    readonly reason: string;
+};
+export type SessionAttachView = {
+    readonly end?: SessionViewEnd;
+    readonly epoch?: string;
+    readonly sequence: number;
+    readonly sessionId?: string;
+    readonly synchronized: boolean;
+    readonly turns: readonly SessionViewTurn[];
+};
+export declare const initialSessionAttachView: SessionAttachView;
+export declare const sessionItemText: (item: SessionItem) => string;
+export declare const isNewSessionRecord: (view: SessionAttachView, record: SessionStreamRecord) => boolean;
+export declare const sessionAttachCursor: (view: SessionAttachView) => undefined | {
+    readonly epoch: string;
+    readonly sequence: number;
+};
+export declare const reduceSessionAttach: (view: SessionAttachView, frame: SessionAttachFrame) => SessionAttachView;
+//# sourceMappingURL=view.d.ts.map

package/dist/session-view/view.js

@@ -0,0 +1,137 @@
+export const MAX_SESSION_VIEW_TURNS = 64;
+export const MAX_SESSION_VIEW_TURN_ITEMS = 256;
+export const initialSessionAttachView = {
+    sequence: 0,
+    synchronized: false,
+    turns: [],
+};
+export const sessionItemText = (item) => {
+    switch (item.kind) {
+        case "message":
+        case "reasoning":
+            return item.text;
+        case "command":
+        case "tool_call":
+            return item.output ?? "";
+        case "approval_request":
+            return item.summary;
+        case "error":
+            return item.message;
+        case "file_change":
+        case "usage":
+            return "";
+    }
+};
+const isTruncated = (item) => "truncated" in item && item.truncated === true;
+export const isNewSessionRecord = (view, record) => record.sequence > view.sequence;
+export const sessionAttachCursor = (view) => view.epoch === undefined
+    ? undefined
+    : { epoch: view.epoch, sequence: view.sequence };
+const withTurn = (turns, turnId, update) => {
+    const index = turns.findIndex((turn) => turn.turnId === turnId);
+    if (index !== -1)
+        return turns.map((turn, position) => position === index ? update(turn) : turn);
+    const added = update({ items: [], status: "running", turnId });
+    return [...turns, added].slice(-MAX_SESSION_VIEW_TURNS);
+};
+const withItem = (turn, itemId, update) => {
+    const index = turn.items.findIndex((item) => item.itemId === itemId);
+    const next = update(index === -1 ? undefined : turn.items[index]);
+    if (next === undefined)
+        return turn;
+    return {
+        ...turn,
+        items: index === -1
+            ? [...turn.items, next].slice(-MAX_SESSION_VIEW_TURN_ITEMS)
+            : turn.items.map((item, position) => position === index ? next : item),
+    };
+};
+const applyItemRecord = (turn, record) => withItem(turn, record.itemId, (current) => {
+    if (record.type === "item.delta")
+        return current === undefined
+            ? undefined
+            : {
+                ...current,
+                sequence: record.sequence,
+                text: current.text + record.delta,
+            };
+    const completed = record.type === "item.completed";
+    if (current !== undefined && current.status !== "open" && !completed)
+        return current;
+    return {
+        item: record.item,
+        itemId: record.itemId,
+        sequence: record.sequence,
+        status: completed ? record.status : "open",
+        text: sessionItemText(record.item),
+        truncated: isTruncated(record.item),
+    };
+});
+const applyRecord = (turns, record) => withTurn(turns, record.turnId, (turn) => {
+    if (record.type === "turn.started")
+        return turn;
+    if (record.type === "turn.completed")
+        return {
+            ...turn,
+            ...(record.failure === undefined ? {} : { failure: record.failure }),
+            status: record.status,
+        };
+    return applyItemRecord(turn, record);
+});
+const applyRecords = (view, records) => records.reduce((current, record) => isNewSessionRecord(current, record)
+    ? {
+        ...current,
+        sequence: record.sequence,
+        turns: applyRecord(current.turns, record),
+    }
+    : current, view);
+const applySynchronized = (view, frame) => ({
+    ...view,
+    sequence: Math.max(view.sequence, frame.data.sequence),
+    synchronized: true,
+    turns: frame.data.openItems.reduce((turns, open) => withTurn(turns, open.turnId, (turn) => withItem(turn, open.itemId, (current) => current === undefined
+        ? undefined
+        : {
+            ...current,
+            sequence: Math.max(current.sequence, open.sequence),
+            text: open.text,
+            truncated: current.truncated || open.truncated === true,
+        })), view.turns),
+});
+const applyAttached = (view, frame) => {
+    const restart = frame.data.mode === "snapshot" ||
+        frame.data.epoch !== view.epoch ||
+        frame.data.sessionId !== view.sessionId;
+    const base = restart ? initialSessionAttachView : view;
+    return {
+        epoch: frame.data.epoch,
+        sequence: base.sequence,
+        sessionId: frame.data.sessionId,
+        synchronized: false,
+        turns: base.turns,
+    };
+};
+export const reduceSessionAttach = (view, frame) => {
+    switch (frame.kind) {
+        case "attached":
+            return applyAttached(view, frame);
+        case "records":
+            return applyRecords(view, frame.data.records);
+        case "synchronized":
+            return applySynchronized(view, frame);
+        case "heartbeat":
+            return view;
+        case "resync":
+            return { ...view, end: { kind: "resync", reason: frame.data.reason } };
+        case "error":
+            return {
+                ...view,
+                end: {
+                    code: frame.data.error.code,
+                    kind: "error",
+                    message: frame.data.error.message,
+                },
+            };
+    }
+};
+//# sourceMappingURL=view.js.map

package/dist/stream/effect.d.ts

@@ -0,0 +1,29 @@
+import type { ProtocolError } from "@maiaos/protocol";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Stream from "effect/Stream";
+import { MaiaClientError } from "../request/index.js";
+import type { StreamRelay } from "./stream.js";
+export type ResumeStep = {
+    readonly cursor?: string;
+    readonly kind: "frame";
+} | {
+    readonly error: ProtocolError;
+    readonly kind: "error";
+} | {
+    readonly kind: "resnapshot";
+};
+export declare const RESNAPSHOT: {
+    readonly kind: "resnapshot";
+};
+export type Resumable<TSubscribe, TFrame> = {
+    readonly decode: (text: string, messageId: string) => Option.Option<TFrame>;
+    readonly nextId: (prefix: "request") => Effect.Effect<string>;
+    readonly relay: StreamRelay<TSubscribe>;
+    readonly step: (frame: TFrame) => ResumeStep;
+    readonly subscribe: (messageId: string, cursor?: string) => TSubscribe;
+    readonly terminal: (frame: TFrame) => boolean;
+};
+export declare const MAX_BUFFERED_FRAMES = 256;
+export declare const resumeStream: <TSubscribe, TFrame>(input: Resumable<TSubscribe, TFrame>) => Stream.Stream<TFrame | typeof RESNAPSHOT, MaiaClientError>;
+//# sourceMappingURL=effect.d.ts.map

package/dist/stream/effect.js

@@ -0,0 +1,77 @@
+import * as Cause from "effect/Cause";
+import * as Duration from "effect/Duration";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Queue from "effect/Queue";
+import * as Ref from "effect/Ref";
+import * as Stream from "effect/Stream";
+import { MaiaClientError } from "../request/index.js";
+export const RESNAPSHOT = { kind: "resnapshot" };
+export const MAX_BUFFERED_FRAMES = 256;
+const MAX_RESNAPSHOTS = 3;
+const RECONNECT_AFTER = Duration.seconds(2);
+const RESUBSCRIBE_AFTER = Duration.millis(250);
+const RELAY_CLOSED = Symbol("relay closed");
+const OVERFLOWED = Symbol("buffer overflowed");
+const ended = (reason) => new MaiaClientError("transport_failure", reason === RELAY_CLOSED
+    ? "The Maia Node stream relay closed."
+    : "The Maia Node stream outran its consumer.", { cause: reason });
+const invalidFrame = () => new MaiaClientError("invalid_response", "The Maia Node stream frame is invalid.");
+const tooManyResnapshots = () => new MaiaClientError("saturated", "The Maia Node stream keeps asking for a fresh snapshot.");
+const fail = (queue, error) => {
+    Queue.failCauseUnsafe(queue, Cause.fail(error));
+};
+const offer = (queue, decode, terminal) => (event) => {
+    if (event.kind === "closed") {
+        fail(queue, ended(RELAY_CLOSED));
+        return;
+    }
+    const frame = decode(event.text);
+    if (Option.isNone(frame)) {
+        fail(queue, invalidFrame());
+        return;
+    }
+    if (!Queue.offerUnsafe(queue, frame.value)) {
+        fail(queue, ended(OVERFLOWED));
+        return;
+    }
+    if (terminal(frame.value))
+        Queue.endUnsafe(queue);
+};
+const subscribeFailed = (cause) => new MaiaClientError("transport_failure", "The Maia Node stream relay could not subscribe.", { cause });
+const relayInto = (input, queue, subscribe) => Effect.acquireRelease(Effect.tryPromise({
+    catch: subscribeFailed,
+    try: () => input.relay(input.subscribe(subscribe.messageId, subscribe.cursor), offer(queue, (text) => input.decode(text, subscribe.messageId), input.terminal)),
+}), (cancel) => Effect.ignore(Effect.tryPromise(() => Promise.resolve(cancel())))).pipe(Effect.catch((error) => Effect.sync(() => {
+    fail(queue, error);
+})));
+const subscription = (input, cursor) => Stream.unwrap(Effect.map(input.nextId("request"), (messageId) => Stream.callback((queue) => relayInto(input, queue, {
+    messageId,
+    ...(cursor === undefined ? {} : { cursor }),
+}), { bufferSize: MAX_BUFFERED_FRAMES, strategy: "suspend" })));
+const advance = (position, frame, step) => {
+    if (step.kind === "error")
+        return Effect.fail(new MaiaClientError("remote_error", step.error.message, {
+            remoteError: step.error,
+        }));
+    if (step.kind === "resnapshot")
+        return resnapshot(position);
+    return Effect.as(Ref.update(position, (current) => ({
+        cursor: step.cursor === undefined ? current.cursor : Option.some(step.cursor),
+        resnapshots: 0,
+    })), frame);
+};
+const resnapshot = (position) => Effect.flatMap(Ref.updateAndGet(position, (current) => ({
+    cursor: Option.none(),
+    resnapshots: current.resnapshots + 1,
+})), (current) => current.resnapshots > MAX_RESNAPSHOTS
+    ? Effect.fail(tooManyResnapshots())
+    : Effect.succeed(RESNAPSHOT));
+const endedBy = (reason) => (error) => error.cause === reason;
+const pause = (duration) => Stream.drain(Stream.fromEffect(Effect.sleep(duration)));
+const once = (input, position) => Stream.unwrap(Effect.map(Ref.get(position), ({ cursor }) => subscription(input, Option.getOrUndefined(cursor)))).pipe(Stream.mapEffect((frame) => advance(position, frame, input.step(frame))));
+export const resumeStream = (input) => Stream.unwrap(Effect.map(Ref.make({ cursor: Option.none(), resnapshots: 0 }), (position) => {
+    const resumed = once(input, position).pipe(Stream.catchIf(endedBy(RELAY_CLOSED), () => pause(RECONNECT_AFTER)), Stream.catchIf(endedBy(OVERFLOWED), () => Stream.fromEffect(resnapshot(position))), Stream.concat(pause(RESUBSCRIBE_AFTER)), Stream.concat(Stream.suspend(() => resumed)));
+    return resumed;
+}));
+//# sourceMappingURL=effect.js.map

package/dist/stream/index.d.ts

@@ -0,0 +1,2 @@
+export type { StreamRelay, StreamRelayEvent } from "./stream.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/stream/index.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.js.map

package/dist/stream/stream.d.ts

@@ -0,0 +1,9 @@
+export type StreamRelayEvent = {
+    readonly kind: "closed";
+    readonly reason: string;
+} | {
+    readonly kind: "frame";
+    readonly text: string;
+};
+export type StreamRelay<TSubscribe> = (subscribe: TSubscribe, onEvent: (event: StreamRelayEvent) => void) => Promise<() => Promise<void> | void>;
+//# sourceMappingURL=stream.d.ts.map

package/dist/stream/stream.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=stream.js.map

package/dist/voice/effect.d.ts

@@ -0,0 +1,7 @@
+import { type EffectClient, type LocalNodeEffectRequester } from "../request/effect.js";
+import { MaiaClientError } from "../request/index.js";
+import type { VoiceManagedTurnClient } from "./managed-turn.js";
+import type { InvalidVoicePiRelayResponse, VoicePiRelayClient } from "./pi-relay.js";
+export declare const makeVoiceManagedTurnOperations: (request: LocalNodeEffectRequester<unknown>) => EffectClient<VoiceManagedTurnClient>;
+export declare const makeVoicePiRelayOperations: <TError>(request: LocalNodeEffectRequester<TError>, invalidResponse: InvalidVoicePiRelayResponse) => EffectClient<VoicePiRelayClient, MaiaClientError | TError>;
+//# sourceMappingURL=effect.d.ts.map

package/dist/voice/effect.js

@@ -0,0 +1,71 @@
+import { turnSendResultSchema } from "@maiaos/protocol";
+import { voiceManagedTurnConfirmParametersSchema, voiceManagedTurnPreviewParametersSchema, voiceManagedTurnPreviewResultSchema, } from "@maiaos/protocol/voice-orchestrator";
+import { Effect } from "effect";
+import { failInvalidResponse, } from "../request/effect.js";
+import { MaiaClientError } from "../request/index.js";
+import { voiceWire } from "./wire-schema.js";
+const invalidManagedTurnResponse = () => new MaiaClientError("invalid_response", "The managed voice response did not match the request.");
+const validate = (schema, value) => Effect.try({
+    catch: () => new MaiaClientError("invalid_request", "The managed voice request is invalid."),
+    try: () => schema.parse(value),
+});
+const managedTurnFailure = (error) => error instanceof MaiaClientError ? error : invalidManagedTurnResponse();
+const matchesConfirmation = (result, parameters) => result.turn.sessionId === parameters.sessionId &&
+    result.receipt.commandId === parameters.confirmation.commandId &&
+    result.receipt.method === "turn.send" &&
+    result.receipt.target.id === result.turn.id &&
+    result.receipt.target.type === "turn";
+const matchesPreview = (result, parameters) => result.sessionId === parameters.sessionId &&
+    result.projectId === parameters.projectId &&
+    result.voiceSessionId === parameters.scopeId &&
+    result.expectedSessionRevision === parameters.expectedSessionRevision &&
+    result.turnInput === parameters.utterance.trim();
+const confirmVoiceManagedTurn = (request, parameters, options) => Effect.gen(function* () {
+    const validated = yield* validate(voiceManagedTurnConfirmParametersSchema, parameters);
+    const result = yield* request({ method: "voice.managed-turn.confirm", parameters: validated }, turnSendResultSchema, options).pipe(Effect.mapError(managedTurnFailure));
+    if (!matchesConfirmation(result, validated))
+        return yield* Effect.fail(invalidManagedTurnResponse());
+    return result;
+});
+const previewVoiceManagedTurn = (request, parameters, options) => Effect.gen(function* () {
+    const validated = yield* validate(voiceManagedTurnPreviewParametersSchema, parameters);
+    const result = yield* request({ method: "voice.managed-turn.preview", parameters: validated }, voiceManagedTurnPreviewResultSchema, options).pipe(Effect.mapError(managedTurnFailure));
+    if (!matchesPreview(result, validated))
+        return yield* Effect.fail(invalidManagedTurnResponse());
+    return result;
+});
+export const makeVoiceManagedTurnOperations = (request) => ({
+    confirmVoiceManagedTurn: (parameters, options) => confirmVoiceManagedTurn(request, parameters, options),
+    previewVoiceManagedTurn: (parameters, options) => previewVoiceManagedTurn(request, parameters, options),
+});
+const matchedRelayResult = (context, result, matches) => matches
+    ? Effect.succeed(result)
+    : failInvalidResponse(context.invalidResponse);
+const requestVoicePiRelayPreview = (context, parameters, options) => Effect.suspend(() => context.request({
+    method: "voice.pi.relay.preview",
+    parameters: voiceWire.previewParameters(parameters),
+}, { parse: (value) => voiceWire.previewResult(value) }, options)).pipe(Effect.flatMap((result) => matchedRelayResult(context, result, result.commandId === parameters.commandId &&
+    result.workspaceId === parameters.workspaceId &&
+    result.workspaceRevision === parameters.expectedWorkspaceRevision &&
+    result.contextRevision === parameters.expectedContextRevision)));
+const requestVoicePiRelayReconcile = (context, parameters, options) => Effect.suspend(() => context.request({
+    method: "voice.pi.relay.reconcile",
+    parameters: voiceWire.reconcileParameters(parameters),
+}, { parse: (value) => voiceWire.reconcileResult(value) }, options)).pipe(Effect.flatMap((result) => matchedRelayResult(context, result, result.commandId === parameters.commandId)));
+const requestConfirmedVoicePiRelay = (context, parameters, options) => Effect.suspend(() => context.request({
+    method: "voice.pi.relay",
+    parameters: voiceWire.relayParameters(parameters),
+}, { parse: (value) => voiceWire.relayResult(value) }, options)).pipe(Effect.flatMap((result) => matchedRelayResult(context, result, result.commandId === parameters.commandId &&
+    result.workspaceId === parameters.workspaceId &&
+    result.sessionId === parameters.sessionId &&
+    result.workspaceRevision === parameters.expectedWorkspaceRevision &&
+    result.contextRevision === parameters.expectedContextRevision)));
+export const makeVoicePiRelayOperations = (request, invalidResponse) => {
+    const context = { invalidResponse, request };
+    return {
+        previewVoiceToPi: (parameters, options) => requestVoicePiRelayPreview(context, parameters, options),
+        reconcileVoiceToPi: (parameters, options) => requestVoicePiRelayReconcile(context, parameters, options),
+        relayVoiceToPi: (parameters, options) => requestConfirmedVoicePiRelay(context, parameters, options),
+    };
+};
+//# sourceMappingURL=effect.js.map

package/dist/voice/index.d.ts

@@ -0,0 +1,4 @@
+export { makeVoiceManagedTurnClient, type VoiceManagedTurnClient, } from "./managed-turn.js";
+export type { VoiceOrchestratorClient } from "./orchestrator.js";
+export { type InvalidVoicePiRelayResponse, makeVoicePiRelayClient, type VoicePiRelayClient, } from "./pi-relay.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/voice/index.js

@@ -0,0 +1,3 @@
+export { makeVoiceManagedTurnClient, } from "./managed-turn.js";
+export { makeVoicePiRelayClient, } from "./pi-relay.js";
+//# sourceMappingURL=index.js.map

package/dist/voice/managed-turn.d.ts

@@ -0,0 +1,9 @@
+import type { TurnSendResult } from "@maiaos/protocol";
+import type { VoiceManagedTurnConfirmParameters, VoiceManagedTurnPreviewParameters, VoiceManagedTurnPreviewResult } from "@maiaos/protocol/voice-orchestrator";
+import type { LocalNodeRequester, LocalNodeRequestOptions } from "../request/index.js";
+export type VoiceManagedTurnClient = {
+    readonly confirmVoiceManagedTurn: (parameters: VoiceManagedTurnConfirmParameters, options: LocalNodeRequestOptions) => Promise<TurnSendResult>;
+    readonly previewVoiceManagedTurn: (parameters: VoiceManagedTurnPreviewParameters, options: LocalNodeRequestOptions) => Promise<VoiceManagedTurnPreviewResult>;
+};
+export declare const makeVoiceManagedTurnClient: (request: LocalNodeRequester) => VoiceManagedTurnClient;
+//# sourceMappingURL=managed-turn.d.ts.map

package/dist/voice/managed-turn.js

@@ -0,0 +1,4 @@
+import { fromPromiseRequester, toPromiseClient } from "../request/effect.js";
+import { makeVoiceManagedTurnOperations } from "./effect.js";
+export const makeVoiceManagedTurnClient = (request) => toPromiseClient(makeVoiceManagedTurnOperations(fromPromiseRequester(request)));
+//# sourceMappingURL=managed-turn.js.map

package/dist/voice/orchestrator-contract.d.ts

@@ -0,0 +1,5 @@
+export { createVoiceOrchestratorClient, type VoiceOrchestratorClient, VoiceOrchestratorClientError, type VoiceOrchestratorClientErrorCode, type VoiceOrchestratorRequestOptions, type VoiceOrchestratorTransport, } from "./orchestrator.js";
+export type { VoiceOrchestratorContextShowParameters, VoiceOrchestratorContextShowResult, VoiceOrchestratorToolCall, VoiceOrchestratorToolCallParameters, VoiceOrchestratorToolCallResult, VoiceOrchestratorToolDefinition, VoiceOrchestratorToolParameters, VoiceOrchestratorToolResult, } from "@maiaos/protocol/voice-orchestrator";
+export { VOICE_MANAGED_TURN_SCHEMA_VERSION, type VoiceManagedTurnConfirmParameters, voiceManagedTurnConfirmParametersSchema, type VoiceManagedTurnPreviewParameters, voiceManagedTurnPreviewParametersSchema, type VoiceManagedTurnPreviewResult, voiceManagedTurnPreviewResultSchema, } from "@maiaos/protocol/voice-orchestrator";
+export { MAX_VOICE_ORCHESTRATOR_CONTEXT_BYTES, MAX_VOICE_ORCHESTRATOR_SAFE_MESSAGE_BYTES, MAX_VOICE_ORCHESTRATOR_TOOL_CALLS, MAX_VOICE_ORCHESTRATOR_TOOL_OUTPUT_BYTES, MAX_VOICE_ORCHESTRATOR_TOOL_REQUEST_BYTES, VOICE_ORCHESTRATOR_ASK_AUTHORITY, VOICE_ORCHESTRATOR_CONTEXT_SCHEMA_VERSION, VOICE_ORCHESTRATOR_OPERATION_BINDINGS, VOICE_ORCHESTRATOR_REVIEWED_SKILL, VOICE_ORCHESTRATOR_REVIEWED_SKILL_PROJECTION, VOICE_ORCHESTRATOR_SYSTEM_PROMPT, VOICE_ORCHESTRATOR_SYSTEM_PROMPT_SCHEMA, VOICE_ORCHESTRATOR_SYSTEM_PROMPT_SHA256, VOICE_ORCHESTRATOR_SYSTEM_PROMPT_VERSION, VOICE_ORCHESTRATOR_TOOL_CALL_RESULT_SCHEMA_VERSION, VOICE_ORCHESTRATOR_TOOL_DEFINITION, VOICE_ORCHESTRATOR_TOOL_DEFINITIONS, VOICE_ORCHESTRATOR_TOOL_DESCRIPTION, VOICE_ORCHESTRATOR_TOOL_NAME, VOICE_ORCHESTRATOR_TOOL_RESULT_SCHEMA_VERSION, VOICE_ORCHESTRATOR_TOOL_SCHEMA_VERSION, voiceOrchestratorContextShowParametersSchema, voiceOrchestratorContextShowResultSchema, voiceOrchestratorToolCallParametersSchema, voiceOrchestratorToolCallResultSchema, voiceOrchestratorToolCallSchema, voiceOrchestratorToolDefinitionSchema, voiceOrchestratorToolParametersSchema, voiceOrchestratorToolResultSchema, } from "@maiaos/protocol/voice-orchestrator";
+//# sourceMappingURL=orchestrator-contract.d.ts.map

package/dist/voice/orchestrator-contract.js

@@ -0,0 +1,4 @@
+export { createVoiceOrchestratorClient, VoiceOrchestratorClientError, } from "./orchestrator.js";
+export { VOICE_MANAGED_TURN_SCHEMA_VERSION, voiceManagedTurnConfirmParametersSchema, voiceManagedTurnPreviewParametersSchema, voiceManagedTurnPreviewResultSchema, } from "@maiaos/protocol/voice-orchestrator";
+export { MAX_VOICE_ORCHESTRATOR_CONTEXT_BYTES, MAX_VOICE_ORCHESTRATOR_SAFE_MESSAGE_BYTES, MAX_VOICE_ORCHESTRATOR_TOOL_CALLS, MAX_VOICE_ORCHESTRATOR_TOOL_OUTPUT_BYTES, MAX_VOICE_ORCHESTRATOR_TOOL_REQUEST_BYTES, VOICE_ORCHESTRATOR_ASK_AUTHORITY, VOICE_ORCHESTRATOR_CONTEXT_SCHEMA_VERSION, VOICE_ORCHESTRATOR_OPERATION_BINDINGS, VOICE_ORCHESTRATOR_REVIEWED_SKILL, VOICE_ORCHESTRATOR_REVIEWED_SKILL_PROJECTION, VOICE_ORCHESTRATOR_SYSTEM_PROMPT, VOICE_ORCHESTRATOR_SYSTEM_PROMPT_SCHEMA, VOICE_ORCHESTRATOR_SYSTEM_PROMPT_SHA256, VOICE_ORCHESTRATOR_SYSTEM_PROMPT_VERSION, VOICE_ORCHESTRATOR_TOOL_CALL_RESULT_SCHEMA_VERSION, VOICE_ORCHESTRATOR_TOOL_DEFINITION, VOICE_ORCHESTRATOR_TOOL_DEFINITIONS, VOICE_ORCHESTRATOR_TOOL_DESCRIPTION, VOICE_ORCHESTRATOR_TOOL_NAME, VOICE_ORCHESTRATOR_TOOL_RESULT_SCHEMA_VERSION, VOICE_ORCHESTRATOR_TOOL_SCHEMA_VERSION, voiceOrchestratorContextShowParametersSchema, voiceOrchestratorContextShowResultSchema, voiceOrchestratorToolCallParametersSchema, voiceOrchestratorToolCallResultSchema, voiceOrchestratorToolCallSchema, voiceOrchestratorToolDefinitionSchema, voiceOrchestratorToolParametersSchema, voiceOrchestratorToolResultSchema, } from "@maiaos/protocol/voice-orchestrator";
+//# sourceMappingURL=orchestrator-contract.js.map

package/dist/voice/orchestrator.d.ts

@@ -0,0 +1,25 @@
+import { type ProtocolError, type ProtocolRequestEnvelope } from "@maiaos/protocol";
+import type { VoiceOrchestratorContextShowParameters, VoiceOrchestratorContextShowResult, VoiceOrchestratorToolCallParameters, VoiceOrchestratorToolCallResult } from "@maiaos/protocol/voice-orchestrator";
+export type VoiceOrchestratorRequestOptions = {
+    readonly messageId: string;
+    readonly signal?: AbortSignal;
+};
+export type VoiceOrchestratorTransport = {
+    readonly request: (envelope: ProtocolRequestEnvelope<unknown>, options?: {
+        readonly signal?: AbortSignal;
+    }) => Promise<unknown>;
+};
+export type VoiceOrchestratorClient = {
+    readonly callVoiceOrchestratorTool: (parameters: VoiceOrchestratorToolCallParameters, options: VoiceOrchestratorRequestOptions) => Promise<VoiceOrchestratorToolCallResult>;
+    readonly showVoiceOrchestratorContext: (parameters: VoiceOrchestratorContextShowParameters, options: VoiceOrchestratorRequestOptions) => Promise<VoiceOrchestratorContextShowResult>;
+};
+export type VoiceOrchestratorClientErrorCode = "cancelled" | "correlation_mismatch" | "deadline_exceeded" | "invalid_request" | "invalid_response" | "outcome_unknown" | "remote_error" | "saturated" | "transport_failure";
+export declare class VoiceOrchestratorClientError extends Error {
+    readonly code: VoiceOrchestratorClientErrorCode;
+    readonly remoteError?: ProtocolError;
+    constructor(code: VoiceOrchestratorClientErrorCode, message: string, options?: ErrorOptions & {
+        readonly remoteError?: ProtocolError;
+    });
+}
+export declare const createVoiceOrchestratorClient: (transport: VoiceOrchestratorTransport) => VoiceOrchestratorClient;
+//# sourceMappingURL=orchestrator.d.ts.map