@moxt-ai/mobius-sdk 0.0.100 → 0.0.102

package/dist/protocol/prompt-usage.d.ts

@@ -0,0 +1,76 @@
+import { z } from "zod";
+export declare const promptUsageSchema: z.ZodReadonly<z.ZodObject<{
+    cachedReadTokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    cachedWriteTokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    inputTokens: z.ZodNumber;
+    outputTokens: z.ZodNumber;
+    thoughtTokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    totalTokens: z.ZodNumber;
+}, z.core.$strip>>;
+export declare const promptMetadataSchema: z.ZodReadonly<z.ZodObject<{
+    quota: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+        model_usage: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            model: z.ZodString;
+            token_count: z.ZodPreprocess<z.ZodReadonly<z.ZodObject<{
+                cachedInputTokens: z.ZodOptional<z.ZodNumber>;
+                cachedWriteTokens: z.ZodOptional<z.ZodNumber>;
+                inputTokens: z.ZodNumber;
+                outputTokens: z.ZodNumber;
+                reasoningOutputTokens: z.ZodOptional<z.ZodNumber>;
+                totalTokens: z.ZodNumber;
+            }, z.core.$strip>>, unknown>;
+        }, z.core.$strip>>>>;
+        token_count: z.ZodNullable<z.ZodPreprocess<z.ZodReadonly<z.ZodObject<{
+            cachedInputTokens: z.ZodOptional<z.ZodNumber>;
+            cachedWriteTokens: z.ZodOptional<z.ZodNumber>;
+            inputTokens: z.ZodNumber;
+            outputTokens: z.ZodNumber;
+            reasoningOutputTokens: z.ZodOptional<z.ZodNumber>;
+            totalTokens: z.ZodNumber;
+        }, z.core.$strip>>, unknown>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>>;
+declare const agentPromptResponseSchema: z.ZodReadonly<z.ZodObject<{
+    _meta: z.ZodOptional<z.ZodNullable<z.ZodReadonly<z.ZodObject<{
+        quota: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+            model_usage: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                model: z.ZodString;
+                token_count: z.ZodPreprocess<z.ZodReadonly<z.ZodObject<{
+                    cachedInputTokens: z.ZodOptional<z.ZodNumber>;
+                    cachedWriteTokens: z.ZodOptional<z.ZodNumber>;
+                    inputTokens: z.ZodNumber;
+                    outputTokens: z.ZodNumber;
+                    reasoningOutputTokens: z.ZodOptional<z.ZodNumber>;
+                    totalTokens: z.ZodNumber;
+                }, z.core.$strip>>, unknown>;
+            }, z.core.$strip>>>>;
+            token_count: z.ZodNullable<z.ZodPreprocess<z.ZodReadonly<z.ZodObject<{
+                cachedInputTokens: z.ZodOptional<z.ZodNumber>;
+                cachedWriteTokens: z.ZodOptional<z.ZodNumber>;
+                inputTokens: z.ZodNumber;
+                outputTokens: z.ZodNumber;
+                reasoningOutputTokens: z.ZodOptional<z.ZodNumber>;
+                totalTokens: z.ZodNumber;
+            }, z.core.$strip>>, unknown>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>>>;
+    stopReason: z.ZodEnum<{
+        cancelled: "cancelled";
+        end_turn: "end_turn";
+        max_tokens: "max_tokens";
+        max_turn_requests: "max_turn_requests";
+        refusal: "refusal";
+    }>;
+    usage: z.ZodOptional<z.ZodNullable<z.ZodReadonly<z.ZodObject<{
+        cachedReadTokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        cachedWriteTokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        inputTokens: z.ZodNumber;
+        outputTokens: z.ZodNumber;
+        thoughtTokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        totalTokens: z.ZodNumber;
+    }, z.core.$strip>>>>;
+}, z.core.$strip>>;
+export type AgentPromptResponse = z.infer<typeof agentPromptResponseSchema>;
+export declare function decodeAgentPromptResponse(value: unknown): AgentPromptResponse;
+export {};
+//# sourceMappingURL=prompt-usage.d.ts.map

package/dist/protocol/prompt-usage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompt-usage.d.ts","sourceRoot":"","sources":["../../src/protocol/prompt-usage.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAkCxB,eAAO,MAAM,iBAAiB;;;;;;;kBASf,CAAC;AAmBhB,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;kBAoBlB,CAAC;AAEhB,QAAA,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAMhB,CAAC;AAEhB,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE5E,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,OAAO,GAAG,mBAAmB,CAQ7E"}

package/dist/protocol/prompt-usage.js

@@ -0,0 +1,88 @@
+import { z } from "zod";
+import { ProtocolMessageError } from "./codecs/messages.js";
+const TOKEN_COUNT = z.number().int().nonnegative();
+function normalizeQuotaTokenCount(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return value;
+    }
+    if (Reflect.has(value, "inputTokens") || Reflect.has(value, "outputTokens") || Reflect.has(value, "totalTokens")) {
+        return value;
+    }
+    if (!Reflect.has(value, "input_tokens") && !Reflect.has(value, "output_tokens")) {
+        return value;
+    }
+    const inputTokens = Reflect.get(value, "input_tokens");
+    const outputTokens = Reflect.get(value, "output_tokens");
+    const reportedTotal = Reflect.get(value, "total_tokens");
+    return {
+        cachedInputTokens: Reflect.get(value, "cached_input_tokens"),
+        cachedWriteTokens: Reflect.get(value, "cached_write_tokens"),
+        inputTokens,
+        outputTokens,
+        reasoningOutputTokens: Reflect.get(value, "reasoning_output_tokens"),
+        totalTokens: reportedTotal === undefined && typeof inputTokens === "number" && typeof outputTokens === "number"
+            ? inputTokens + outputTokens
+            : reportedTotal,
+    };
+}
+// Adapter-reported snapshots, not deltas. Cache and reasoning counters can
+// overlap other counters; consumers must not sum fields or successive reports.
+export const promptUsageSchema = z
+    .object({
+    cachedReadTokens: TOKEN_COUNT.nullish(),
+    cachedWriteTokens: TOKEN_COUNT.nullish(),
+    inputTokens: TOKEN_COUNT,
+    outputTokens: TOKEN_COUNT,
+    thoughtTokens: TOKEN_COUNT.nullish(),
+    totalTokens: TOKEN_COUNT,
+})
+    .readonly();
+const quotaTokenCountSchema = z.preprocess(normalizeQuotaTokenCount, z
+    .object({
+    cachedInputTokens: TOKEN_COUNT.optional(),
+    cachedWriteTokens: TOKEN_COUNT.optional(),
+    inputTokens: TOKEN_COUNT,
+    outputTokens: TOKEN_COUNT,
+    reasoningOutputTokens: TOKEN_COUNT.optional(),
+    totalTokens: TOKEN_COUNT,
+})
+    .readonly());
+// Codex ACP 1.8.0 and Claude ACP 0.73.0 report camel-case quota counters.
+// Gemini CLI 0.59.0 reports bounded snake-case input/output counters instead.
+// Claude model rows can include subagents, so they need not sum to token_count.
+export const promptMetadataSchema = z
+    .object({
+    quota: z
+        .object({
+        model_usage: z
+            .array(z
+            .object({
+            model: z.string().min(1).max(255),
+            token_count: quotaTokenCountSchema,
+        })
+            .readonly())
+            .max(100)
+            .readonly(),
+        token_count: quotaTokenCountSchema.nullable(),
+    })
+        .readonly()
+        .optional(),
+})
+    .readonly();
+const agentPromptResponseSchema = z
+    .object({
+    _meta: promptMetadataSchema.nullish(),
+    stopReason: z.enum(["end_turn", "max_tokens", "max_turn_requests", "refusal", "cancelled"]),
+    usage: promptUsageSchema.nullish(),
+})
+    .readonly();
+export function decodeAgentPromptResponse(value) {
+    const result = agentPromptResponseSchema.safeParse(value);
+    if (!result.success) {
+        throw new ProtocolMessageError("Invalid agent prompt response", {
+            cause: result.error,
+        });
+    }
+    return result.data;
+}
+//# sourceMappingURL=prompt-usage.js.map

package/dist/protocol/prompt-usage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompt-usage.js","sourceRoot":"","sources":["../../src/protocol/prompt-usage.ts"],"names":[],"mappings":"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"}

package/dist/protocol/resource-model.d.ts

@@ -0,0 +1,339 @@
+import { z } from "zod";
+export declare const MAX_LOCAL_AGENT_DIRECTORY_ENTRIES = 32;
+declare const turnStateSchema: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+    kind: z.ZodLiteral<"queued">;
+}, z.core.$strip>>, z.ZodReadonly<z.ZodObject<{
+    kind: z.ZodLiteral<"running">;
+    startedAt: z.ZodString;
+}, z.core.$strip>>, z.ZodReadonly<z.ZodObject<{
+    completedAt: z.ZodString;
+    kind: z.ZodLiteral<"succeeded">;
+    result: z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"agent_result">;
+        stopReason: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>>, z.ZodReadonly<z.ZodObject<{
+    error: z.ZodReadonly<z.ZodObject<{
+        code: z.core.$ZodBranded<z.ZodString, "Identifier", "out">;
+        message: z.ZodString;
+        retryable: z.ZodBoolean;
+    }, z.core.$strip>>;
+    failedAt: z.ZodString;
+    kind: z.ZodLiteral<"failed">;
+}, z.core.$strip>>, z.ZodReadonly<z.ZodObject<{
+    cancelledAt: z.ZodString;
+    kind: z.ZodLiteral<"cancelled">;
+}, z.core.$strip>>, z.ZodReadonly<z.ZodObject<{
+    kind: z.ZodLiteral<"indeterminate">;
+    reconciliation: z.ZodReadonly<z.ZodObject<{
+        detectedAt: z.ZodString;
+        reason: z.ZodEnum<{
+            connection_lost: "connection_lost";
+            dispatch_indeterminate: "dispatch_indeterminate";
+            runtime_restarted: "runtime_restarted";
+        }>;
+    }, z.core.$strip>>;
+}, z.core.$strip>>], "kind">;
+export type TurnState = z.infer<typeof turnStateSchema>;
+declare const turnRequestSchema: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+    content: z.ZodString;
+    kind: z.ZodLiteral<"prompt">;
+    sessionConfigurations: z.ZodDefault<z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+        booleanValue: z.ZodBoolean;
+        configId: z.ZodString;
+        value: z.ZodString;
+        valueType: z.ZodEnum<{
+            boolean: "boolean";
+            select: "select";
+        }>;
+    }, z.core.$strip>>>>>;
+}, z.core.$strip>>, z.ZodReadonly<z.ZodObject<{
+    kind: z.ZodLiteral<"not_retained">;
+}, z.core.$strip>>], "kind">;
+export type TurnRequest = z.infer<typeof turnRequestSchema>;
+declare const turnSchema: z.ZodUnion<readonly [z.ZodReadonly<z.ZodObject<{
+    acceptedAt: z.ZodString;
+    bindingId: z.core.$ZodBranded<z.ZodString, "Identifier", "out">;
+    idempotencyKey: z.core.$ZodBranded<z.ZodString, "Identifier", "out">;
+    sessionId: z.core.$ZodBranded<z.ZodString, "Identifier", "out">;
+    turnId: z.core.$ZodBranded<z.ZodString, "Identifier", "out">;
+    request: z.ZodReadonly<z.ZodObject<{
+        content: z.ZodString;
+        kind: z.ZodLiteral<"prompt">;
+        sessionConfigurations: z.ZodDefault<z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            booleanValue: z.ZodBoolean;
+            configId: z.ZodString;
+            value: z.ZodString;
+            valueType: z.ZodEnum<{
+                boolean: "boolean";
+                select: "select";
+            }>;
+        }, z.core.$strip>>>>>;
+    }, z.core.$strip>>;
+    state: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"queued">;
+    }, z.core.$strip>>, z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"running">;
+        startedAt: z.ZodString;
+    }, z.core.$strip>>, z.ZodReadonly<z.ZodObject<{
+        completedAt: z.ZodString;
+        kind: z.ZodLiteral<"succeeded">;
+        result: z.ZodReadonly<z.ZodObject<{
+            kind: z.ZodLiteral<"agent_result">;
+            stopReason: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>, z.ZodReadonly<z.ZodObject<{
+        error: z.ZodReadonly<z.ZodObject<{
+            code: z.core.$ZodBranded<z.ZodString, "Identifier", "out">;
+            message: z.ZodString;
+            retryable: z.ZodBoolean;
+        }, z.core.$strip>>;
+        failedAt: z.ZodString;
+        kind: z.ZodLiteral<"failed">;
+    }, z.core.$strip>>, z.ZodReadonly<z.ZodObject<{
+        cancelledAt: z.ZodString;
+        kind: z.ZodLiteral<"cancelled">;
+    }, z.core.$strip>>, z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"indeterminate">;
+        reconciliation: z.ZodReadonly<z.ZodObject<{
+            detectedAt: z.ZodString;
+            reason: z.ZodEnum<{
+                connection_lost: "connection_lost";
+                dispatch_indeterminate: "dispatch_indeterminate";
+                runtime_restarted: "runtime_restarted";
+            }>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>], "kind">;
+}, z.core.$strip>>, z.ZodReadonly<z.ZodObject<{
+    acceptedAt: z.ZodString;
+    bindingId: z.core.$ZodBranded<z.ZodString, "Identifier", "out">;
+    idempotencyKey: z.core.$ZodBranded<z.ZodString, "Identifier", "out">;
+    sessionId: z.core.$ZodBranded<z.ZodString, "Identifier", "out">;
+    turnId: z.core.$ZodBranded<z.ZodString, "Identifier", "out">;
+    request: z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"not_retained">;
+    }, z.core.$strip>>;
+    state: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+        completedAt: z.ZodString;
+        kind: z.ZodLiteral<"succeeded">;
+        result: z.ZodReadonly<z.ZodObject<{
+            kind: z.ZodLiteral<"agent_result">;
+            stopReason: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>, z.ZodReadonly<z.ZodObject<{
+        error: z.ZodReadonly<z.ZodObject<{
+            code: z.core.$ZodBranded<z.ZodString, "Identifier", "out">;
+            message: z.ZodString;
+            retryable: z.ZodBoolean;
+        }, z.core.$strip>>;
+        failedAt: z.ZodString;
+        kind: z.ZodLiteral<"failed">;
+    }, z.core.$strip>>, z.ZodReadonly<z.ZodObject<{
+        cancelledAt: z.ZodString;
+        kind: z.ZodLiteral<"cancelled">;
+    }, z.core.$strip>>], "kind">;
+}, z.core.$strip>>]>;
+export type Turn = z.infer<typeof turnSchema>;
+declare const interactionRequestSchema: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+    kind: z.ZodLiteral<"permission">;
+    options: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodEnum<{
+            allow_always: "allow_always";
+            allow_once: "allow_once";
+            reject_always: "reject_always";
+            reject_once: "reject_once";
+        }>;
+        name: z.ZodString;
+        optionId: z.ZodString;
+    }, z.core.$strip>>>>;
+    title: z.ZodString;
+    toolCallId: z.ZodString;
+    toolKind: z.ZodString;
+}, z.core.$strip>>, z.ZodReadonly<z.ZodObject<{
+    elicitationId: z.ZodString;
+    fields: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+        defaultBooleanValue: z.ZodBoolean;
+        defaultNumberValue: z.ZodNumber;
+        defaultStringValue: z.ZodString;
+        description: z.ZodString;
+        format: z.ZodString;
+        hasDefaultValue: z.ZodBoolean;
+        maximum: z.ZodString;
+        maximumLength: z.ZodString;
+        minimum: z.ZodString;
+        minimumLength: z.ZodString;
+        name: z.ZodString;
+        options: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            description: z.ZodString;
+            label: z.ZodString;
+            value: z.ZodString;
+        }, z.core.$strip>>>>;
+        pattern: z.ZodString;
+        required: z.ZodBoolean;
+        title: z.ZodString;
+        type: z.ZodEnum<{
+            boolean: "boolean";
+            integer: "integer";
+            multiselect: "multiselect";
+            number: "number";
+            select: "select";
+            string: "string";
+        }>;
+    }, z.core.$strip>>>>;
+    kind: z.ZodLiteral<"elicitation">;
+    message: z.ZodString;
+    mode: z.ZodEnum<{
+        form: "form";
+        url: "url";
+    }>;
+    url: z.ZodString;
+}, z.core.$strip>>], "kind">;
+export type InteractionRequest = z.infer<typeof interactionRequestSchema>;
+declare const interactionResponseSchema: z.ZodReadonly<z.ZodObject<{
+    content: z.ZodString;
+    kind: z.ZodEnum<{
+        elicitation: "elicitation";
+        permission: "permission";
+    }>;
+}, z.core.$strip>>;
+export type InteractionResponse = z.infer<typeof interactionResponseSchema>;
+declare const interactionStateSchema: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+    kind: z.ZodLiteral<"pending">;
+}, z.core.$strip>>, z.ZodReadonly<z.ZodObject<{
+    kind: z.ZodLiteral<"responded">;
+    respondedAt: z.ZodString;
+    responderId: z.core.$ZodBranded<z.ZodString, "Identifier", "out">;
+    response: z.ZodReadonly<z.ZodObject<{
+        content: z.ZodString;
+        kind: z.ZodEnum<{
+            elicitation: "elicitation";
+            permission: "permission";
+        }>;
+    }, z.core.$strip>>;
+}, z.core.$strip>>, z.ZodReadonly<z.ZodObject<{
+    kind: z.ZodLiteral<"resolved">;
+    resolution: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"without_response">;
+    }, z.core.$strip>>, z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"response_applied">;
+        respondedAt: z.ZodString;
+        responderId: z.core.$ZodBranded<z.ZodString, "Identifier", "out">;
+        response: z.ZodReadonly<z.ZodObject<{
+            content: z.ZodString;
+            kind: z.ZodEnum<{
+                elicitation: "elicitation";
+                permission: "permission";
+            }>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>], "kind">;
+    resolvedAt: z.ZodString;
+}, z.core.$strip>>, z.ZodReadonly<z.ZodObject<{
+    expiredAt: z.ZodString;
+    kind: z.ZodLiteral<"expired">;
+}, z.core.$strip>>, z.ZodReadonly<z.ZodObject<{
+    cancelledAt: z.ZodString;
+    kind: z.ZodLiteral<"cancelled">;
+}, z.core.$strip>>], "kind">;
+export type InteractionState = z.infer<typeof interactionStateSchema>;
+declare const interactionSchema: z.ZodReadonly<z.ZodObject<{
+    attemptId: z.core.$ZodBranded<z.ZodString, "Identifier", "out">;
+    interactionId: z.core.$ZodBranded<z.ZodString, "Identifier", "out">;
+    request: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"permission">;
+        options: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            kind: z.ZodEnum<{
+                allow_always: "allow_always";
+                allow_once: "allow_once";
+                reject_always: "reject_always";
+                reject_once: "reject_once";
+            }>;
+            name: z.ZodString;
+            optionId: z.ZodString;
+        }, z.core.$strip>>>>;
+        title: z.ZodString;
+        toolCallId: z.ZodString;
+        toolKind: z.ZodString;
+    }, z.core.$strip>>, z.ZodReadonly<z.ZodObject<{
+        elicitationId: z.ZodString;
+        fields: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            defaultBooleanValue: z.ZodBoolean;
+            defaultNumberValue: z.ZodNumber;
+            defaultStringValue: z.ZodString;
+            description: z.ZodString;
+            format: z.ZodString;
+            hasDefaultValue: z.ZodBoolean;
+            maximum: z.ZodString;
+            maximumLength: z.ZodString;
+            minimum: z.ZodString;
+            minimumLength: z.ZodString;
+            name: z.ZodString;
+            options: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                description: z.ZodString;
+                label: z.ZodString;
+                value: z.ZodString;
+            }, z.core.$strip>>>>;
+            pattern: z.ZodString;
+            required: z.ZodBoolean;
+            title: z.ZodString;
+            type: z.ZodEnum<{
+                boolean: "boolean";
+                integer: "integer";
+                multiselect: "multiselect";
+                number: "number";
+                select: "select";
+                string: "string";
+            }>;
+        }, z.core.$strip>>>>;
+        kind: z.ZodLiteral<"elicitation">;
+        message: z.ZodString;
+        mode: z.ZodEnum<{
+            form: "form";
+            url: "url";
+        }>;
+        url: z.ZodString;
+    }, z.core.$strip>>], "kind">;
+    sessionId: z.core.$ZodBranded<z.ZodString, "Identifier", "out">;
+    state: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"pending">;
+    }, z.core.$strip>>, z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"responded">;
+        respondedAt: z.ZodString;
+        responderId: z.core.$ZodBranded<z.ZodString, "Identifier", "out">;
+        response: z.ZodReadonly<z.ZodObject<{
+            content: z.ZodString;
+            kind: z.ZodEnum<{
+                elicitation: "elicitation";
+                permission: "permission";
+            }>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>, z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"resolved">;
+        resolution: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+            kind: z.ZodLiteral<"without_response">;
+        }, z.core.$strip>>, z.ZodReadonly<z.ZodObject<{
+            kind: z.ZodLiteral<"response_applied">;
+            respondedAt: z.ZodString;
+            responderId: z.core.$ZodBranded<z.ZodString, "Identifier", "out">;
+            response: z.ZodReadonly<z.ZodObject<{
+                content: z.ZodString;
+                kind: z.ZodEnum<{
+                    elicitation: "elicitation";
+                    permission: "permission";
+                }>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>], "kind">;
+        resolvedAt: z.ZodString;
+    }, z.core.$strip>>, z.ZodReadonly<z.ZodObject<{
+        expiredAt: z.ZodString;
+        kind: z.ZodLiteral<"expired">;
+    }, z.core.$strip>>, z.ZodReadonly<z.ZodObject<{
+        cancelledAt: z.ZodString;
+        kind: z.ZodLiteral<"cancelled">;
+    }, z.core.$strip>>], "kind">;
+    turnId: z.core.$ZodBranded<z.ZodString, "Identifier", "out">;
+}, z.core.$strip>>;
+export type Interaction = z.infer<typeof interactionSchema>;
+export declare const decodeTurn: (value: unknown) => Turn;
+export declare const decodeInteraction: (value: unknown) => Interaction;
+export {};
+//# sourceMappingURL=resource-model.d.ts.map

package/dist/protocol/resource-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resource-model.d.ts","sourceRoot":"","sources":["../../src/protocol/resource-model.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAUxB,eAAO,MAAM,iCAAiC,KAAK,CAAC;AAiDpD,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAUnB,CAAC;AAEH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAUxD,QAAA,MAAM,iBAAiB;;;;;;;;;;;;;;4BAAwF,CAAC;AAEhH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAS5D,QAAA,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAGd,CAAC;AAEH,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC;AAuB9C,QAAA,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAoF,CAAC;AAEnH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE1E,QAAA,MAAM,yBAAyB;;;;;;kBAKhB,CAAC;AAEhB,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE5E,QAAA,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAkC1B,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEtE,QAAA,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBASR,CAAC;AAEhB,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAY5D,eAAO,MAAM,UAAU,UAAW,OAAO,KAAG,IAAyC,CAAC;AACtF,eAAO,MAAM,iBAAiB,UAAW,OAAO,KAAG,WAAuD,CAAC"}

package/dist/protocol/resource-model.js

@@ -0,0 +1,161 @@
+import { z } from "zod";
+import { ProtocolMessageError } from "./codecs/messages.js";
+import { elicitationFieldSchema, permissionOptionSchema, sessionConfigurationSelectionsSchema, } from "./control-messages.js";
+import { identifierSchema } from "./identifier.js";
+export const MAX_LOCAL_AGENT_DIRECTORY_ENTRIES = 32;
+const timestampSchema = z.string().datetime({ offset: true });
+const domainErrorSchema = z
+    .object({
+    code: identifierSchema,
+    message: z.string().min(1).max(2_000),
+    retryable: z.boolean(),
+})
+    .readonly();
+const executionResultSchema = z
+    .object({
+    kind: z.literal("agent_result"),
+    stopReason: z.string().min(1).max(128),
+})
+    .readonly();
+const reconciliationSchema = z
+    .object({
+    detectedAt: timestampSchema,
+    reason: z.enum(["connection_lost", "dispatch_indeterminate", "runtime_restarted"]),
+})
+    .readonly();
+const terminalTurnStateSchema = z.discriminatedUnion("kind", [
+    z
+        .object({
+        completedAt: timestampSchema,
+        kind: z.literal("succeeded"),
+        result: executionResultSchema,
+    })
+        .readonly(),
+    z
+        .object({
+        error: domainErrorSchema,
+        failedAt: timestampSchema,
+        kind: z.literal("failed"),
+    })
+        .readonly(),
+    z
+        .object({
+        cancelledAt: timestampSchema,
+        kind: z.literal("cancelled"),
+    })
+        .readonly(),
+]);
+const turnStateSchema = z.discriminatedUnion("kind", [
+    z.object({ kind: z.literal("queued") }).readonly(),
+    z.object({ kind: z.literal("running"), startedAt: timestampSchema }).readonly(),
+    ...terminalTurnStateSchema.options,
+    z
+        .object({
+        kind: z.literal("indeterminate"),
+        reconciliation: reconciliationSchema,
+    })
+        .readonly(),
+]);
+const promptTurnRequestSchema = z
+    .object({
+    content: z.string().max(100_000),
+    kind: z.literal("prompt"),
+    sessionConfigurations: sessionConfigurationSelectionsSchema.default([]),
+})
+    .readonly();
+const notRetainedTurnRequestSchema = z.object({ kind: z.literal("not_retained") }).readonly();
+const turnRequestSchema = z.discriminatedUnion("kind", [promptTurnRequestSchema, notRetainedTurnRequestSchema]);
+const turnIdentitySchema = z.object({
+    acceptedAt: timestampSchema,
+    bindingId: identifierSchema,
+    idempotencyKey: identifierSchema,
+    sessionId: identifierSchema,
+    turnId: identifierSchema,
+});
+const turnSchema = z.union([
+    turnIdentitySchema.extend({ request: promptTurnRequestSchema, state: turnStateSchema }).readonly(),
+    turnIdentitySchema.extend({ request: notRetainedTurnRequestSchema, state: terminalTurnStateSchema }).readonly(),
+]);
+const permissionRequestSchema = z
+    .object({
+    kind: z.literal("permission"),
+    options: z.array(permissionOptionSchema).min(1).max(20).readonly(),
+    title: z.string().min(1).max(500),
+    toolCallId: z.string().min(1).max(255),
+    toolKind: z.string().max(64),
+})
+    .readonly();
+const elicitationRequestSchema = z
+    .object({
+    elicitationId: z.string().max(255),
+    fields: z.array(elicitationFieldSchema).max(100).readonly(),
+    kind: z.literal("elicitation"),
+    message: z.string().min(1).max(2_000),
+    mode: z.enum(["form", "url"]),
+    url: z.string().max(4_096),
+})
+    .readonly();
+const interactionRequestSchema = z.discriminatedUnion("kind", [permissionRequestSchema, elicitationRequestSchema]);
+const interactionResponseSchema = z
+    .object({
+    content: z.string().max(100_000),
+    kind: z.enum(["permission", "elicitation"]),
+})
+    .readonly();
+const interactionStateSchema = z.discriminatedUnion("kind", [
+    z.object({ kind: z.literal("pending") }).readonly(),
+    z
+        .object({
+        kind: z.literal("responded"),
+        respondedAt: timestampSchema,
+        responderId: identifierSchema,
+        response: interactionResponseSchema,
+    })
+        .readonly(),
+    z
+        .object({
+        kind: z.literal("resolved"),
+        resolution: z.discriminatedUnion("kind", [
+            z.object({ kind: z.literal("without_response") }).readonly(),
+            z
+                .object({
+                kind: z.literal("response_applied"),
+                respondedAt: timestampSchema,
+                responderId: identifierSchema,
+                response: interactionResponseSchema,
+            })
+                .readonly(),
+        ]),
+        resolvedAt: timestampSchema,
+    })
+        .readonly(),
+    z.object({ expiredAt: timestampSchema, kind: z.literal("expired") }).readonly(),
+    z
+        .object({
+        cancelledAt: timestampSchema,
+        kind: z.literal("cancelled"),
+    })
+        .readonly(),
+]);
+const interactionSchema = z
+    .object({
+    attemptId: identifierSchema,
+    interactionId: identifierSchema,
+    request: interactionRequestSchema,
+    sessionId: identifierSchema,
+    state: interactionStateSchema,
+    turnId: identifierSchema,
+})
+    .readonly();
+function decodeResource(value, schema) {
+    const decoded = schema.safeParse(value);
+    if (!decoded.success) {
+        throw new ProtocolMessageError("Resource does not match its schema", {
+            cause: decoded.error,
+        });
+    }
+    return decoded.data;
+}
+export const decodeTurn = (value) => decodeResource(value, turnSchema);
+export const decodeInteraction = (value) => decodeResource(value, interactionSchema);
+//# sourceMappingURL=resource-model.js.map