@markusylisiurunen/tau 0.3.22 → 0.3.24

package/dist/protocol/session_protocol.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-export const SESSION_PROTOCOL_VERSION = 1;
+export const SESSION_PROTOCOL_VERSION = 2;
 export const SESSION_PROTOCOL_METHODS = [
     "initialize",
     "session.create",
@@ -13,6 +13,7 @@ export const SESSION_PROTOCOL_METHODS = [
     "session.cancelPendingMessages",
     "session.retry",
     "session.exec",
+    "session.sample",
     "session.interrupt",
     "session.snapshot",
     "session.setReasoning",
@@ -82,7 +83,116 @@ const nonEmptyStringSchema = z
     .refine((value) => value.trim().length > 0);
 const sessionProtocolRequestIdSchema = nonEmptyStringSchema;
 const nullableSessionProtocolRequestIdSchema = sessionProtocolRequestIdSchema.nullable();
-const messageSchema = z.custom(isMessage);
+const modelTextContentSchema = z
+    .object({
+    type: z.literal("text"),
+    text: z.string(),
+    textSignature: z.string().optional(),
+})
+    .strip();
+const modelImageContentSchema = z
+    .object({
+    type: z.literal("image"),
+    data: z.string(),
+    mimeType: nonEmptyStringSchema,
+})
+    .strip();
+const modelThinkingContentSchema = z
+    .object({
+    type: z.literal("thinking"),
+    thinking: z.string(),
+    thinkingSignature: z.string().optional(),
+    redacted: z.boolean().optional(),
+})
+    .strip();
+const modelToolCallSchema = z
+    .object({
+    type: z.literal("toolCall"),
+    id: nonEmptyStringSchema,
+    name: nonEmptyStringSchema,
+    arguments: z.record(z.string(), z.unknown()),
+    thoughtSignature: z.string().optional(),
+})
+    .strip();
+const modelUsageSchema = z
+    .object({
+    input: z.number().int().nonnegative(),
+    output: z.number().int().nonnegative(),
+    cacheRead: z.number().int().nonnegative(),
+    cacheWrite: z.number().int().nonnegative(),
+    cacheWrite1h: z.number().int().nonnegative().optional(),
+    reasoning: z.number().int().nonnegative().optional(),
+    totalTokens: z.number().int().nonnegative(),
+    cost: z
+        .object({
+        input: z.number().nonnegative(),
+        output: z.number().nonnegative(),
+        cacheRead: z.number().nonnegative(),
+        cacheWrite: z.number().nonnegative(),
+        total: z.number().nonnegative(),
+    })
+        .strip(),
+})
+    .strip();
+const modelUserMessageSchema = z
+    .object({
+    role: z.literal("user"),
+    content: z.union([
+        z.string(),
+        z.array(z.union([modelTextContentSchema, modelImageContentSchema])),
+    ]),
+    timestamp: z.number().finite(),
+})
+    .strip();
+const modelDiagnosticErrorSchema = z
+    .object({
+    name: z.string().optional(),
+    message: z.string(),
+    stack: z.string().optional(),
+    code: z.union([z.string(), z.number()]).optional(),
+})
+    .strip();
+const modelDiagnosticSchema = z
+    .object({
+    type: z.string(),
+    timestamp: z.number().finite(),
+    error: modelDiagnosticErrorSchema.optional(),
+    details: z.record(z.string(), z.unknown()).optional(),
+})
+    .strip();
+const modelAssistantMessageSchema = z
+    .object({
+    role: z.literal("assistant"),
+    content: z.array(z.union([modelTextContentSchema, modelThinkingContentSchema, modelToolCallSchema])),
+    api: nonEmptyStringSchema,
+    provider: nonEmptyStringSchema,
+    model: nonEmptyStringSchema,
+    responseModel: nonEmptyStringSchema.optional(),
+    responseId: nonEmptyStringSchema.optional(),
+    diagnostics: z.array(modelDiagnosticSchema).optional(),
+    usage: modelUsageSchema,
+    stopReason: z.enum(["stop", "length", "toolUse", "error", "aborted"]),
+    errorMessage: z.string().optional(),
+    timestamp: z.number().finite(),
+})
+    .strip();
+const modelToolResultMessageSchema = z
+    .object({
+    role: z.literal("toolResult"),
+    toolCallId: nonEmptyStringSchema,
+    toolName: nonEmptyStringSchema,
+    content: z.array(z.union([modelTextContentSchema, modelImageContentSchema])),
+    details: z.unknown().optional(),
+    addedToolNames: z.array(nonEmptyStringSchema).optional(),
+    isError: z.boolean(),
+    timestamp: z.number().finite(),
+})
+    .strip();
+const modelMessageSchema = z.union([
+    modelUserMessageSchema,
+    modelAssistantMessageSchema,
+    modelToolResultMessageSchema,
+]);
 const sessionProtocolReadyMessageSchema = z
     .object({
     version: z.literal(SESSION_PROTOCOL_VERSION),
@@ -201,11 +311,6 @@ const sessionProtocolExecParamsSchema = z
     timeoutMs: z.number().int().positive().optional(),
 })
     .strip();
-const sessionProtocolSessionIdParamsSchema = z
-    .object({
-    sessionId: nonEmptyStringSchema,
-})
-    .strip();
 const sessionProtocolReasoningEffortSchema = z.enum([
     "none",
     "minimal",
@@ -215,6 +320,36 @@ const sessionProtocolReasoningEffortSchema = z.enum([
     "xhigh",
     "max",
 ]);
+const sessionProtocolSampleToolSchema = z
+    .object({
+    name: nonEmptyStringSchema,
+    description: z.string(),
+    parameters: z.record(z.string(), z.unknown()),
+})
+    .strip();
+const sessionProtocolSampleParamsSchema = z
+    .object({
+    sessionId: nonEmptyStringSchema,
+    context: z
+        .object({
+        systemPrompt: z.string(),
+        messages: z.array(modelMessageSchema),
+        tools: z.array(sessionProtocolSampleToolSchema).optional(),
+    })
+        .strip(),
+    options: z
+        .object({
+        reasoning: sessionProtocolReasoningEffortSchema.optional(),
+        maxTokens: z.number().int().positive().optional(),
+    })
+        .strip(),
+})
+    .strip();
+const sessionProtocolSessionIdParamsSchema = z
+    .object({
+    sessionId: nonEmptyStringSchema,
+})
+    .strip();
 const sessionProtocolSetReasoningParamsSchema = z
     .object({
     sessionId: nonEmptyStringSchema,
@@ -322,10 +457,14 @@ const sessionProtocolClientToolResultParamsSchema = z.discriminatedUnion("ok", [
         .strip(),
 ]);
 const absolutePathSchema = nonEmptyStringSchema.refine((value) => value.startsWith("/"));
+const environmentVariableNameSchema = z.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/);
+const environmentVariableValueSchema = z.string().refine((value) => !value.includes("\0"));
+const environmentVariablesSchema = z.record(environmentVariableNameSchema, environmentVariableValueSchema);
 const sessionProtocolLocalExecutionEnvironmentInputSchema = z
     .object({
     kind: z.literal("local"),
     cwd: absolutePathSchema,
+    env: environmentVariablesSchema.optional(),
 })
     .strip();
 const sessionProtocolCloudflareSandboxExecutionEnvironmentInputSchema = z
@@ -470,6 +609,7 @@ const sessionProtocolLocalExecutionEnvironmentSnapshotSchema = z
     kind: z.literal("local"),
     cwd: nonEmptyStringSchema,
     home: nonEmptyStringSchema,
+    env: environmentVariablesSchema.optional(),
 })
     .strip();
 const sessionProtocolCloudflareSandboxExecutionEnvironmentSnapshotSchema = z
@@ -511,15 +651,44 @@ const sessionProtocolDraftAssistantMessageSchema = z
     .strip();
 const sessionProtocolMessagePayloadSchema = z.union([
     sessionProtocolSystemMessageSchema,
-    messageSchema,
+    modelMessageSchema,
     sessionProtocolDraftAssistantMessageSchema,
 ]);
+const sessionProtocolTurnOutcomeSchema = z.discriminatedUnion("status", [
+    z
+        .object({
+        status: z.literal("completed"),
+        stopReason: z.enum(["stop", "length", "toolUse"]),
+    })
+        .strip(),
+    z
+        .object({
+        status: z.literal("failed"),
+        stopReason: z.literal("error"),
+        errorMessage: z.string().optional(),
+    })
+        .strip(),
+    z
+        .object({
+        status: z.literal("aborted"),
+        stopReason: z.literal("aborted"),
+    })
+        .strip(),
+    z
+        .object({
+        status: z.literal("blocked"),
+        reason: z.literal("auto-compaction-failed"),
+        message: z.string(),
+    })
+        .strip(),
+]);
 const sessionProtocolMessageSchema = z
     .object({
     id: nonEmptyStringSchema,
     state: z.enum(["draft", "committed", "interrupted", "discarded"]),
     modelVisible: z.boolean(),
     message: sessionProtocolMessagePayloadSchema,
+    turn: sessionProtocolTurnOutcomeSchema.optional(),
 })
     .strip();
 const sessionProtocolNoticeSchema = z
@@ -655,6 +824,13 @@ const sessionProtocolSnapshotSchema = z
                 message: `duplicate message id '${message.id}'`,
             });
         }
+        if (message.turn && message.message.role !== "user") {
+            ctx.addIssue({
+                code: "custom",
+                path: ["messages"],
+                message: `turn outcome belongs to non-user message '${message.id}'`,
+            });
+        }
         messagesById.set(message.id, message);
     }
     const timelineIds = new Set();
@@ -1029,18 +1205,7 @@ const sessionProtocolListResultSchema = z
     .strip();
 const sessionProtocolSubmitResultSchema = z
     .object({
-    turn: z
-        .object({
-        aborted: z.boolean(),
-        blocked: z
-            .object({
-            reason: z.literal("auto-compaction-failed"),
-            message: z.string(),
-        })
-            .strip()
-            .optional(),
-    })
-        .strip(),
+    turn: sessionProtocolTurnOutcomeSchema,
 })
     .strip();
 const sessionProtocolTurnResultSchema = sessionProtocolSubmitResultSchema;
@@ -1070,6 +1235,11 @@ const sessionProtocolExecResultSchema = z
     truncated: z.boolean(),
 })
     .strip();
+const sessionProtocolSampleResultSchema = z
+    .object({
+    message: modelAssistantMessageSchema,
+})
+    .strip();
 const sessionProtocolInterruptResultSchema = z
     .object({
     interrupted: z.boolean(),
@@ -1674,6 +1844,8 @@ export function validateSessionProtocolParams(method, params) {
             return validateUserMessageParams(method, params);
         case "session.exec":
             return validateExecParams(params);
+        case "session.sample":
+            return validateSampleParams(params);
         case "session.list":
             return validateNoParams(method, params);
         case "session.cancelPendingMessages":
@@ -1763,6 +1935,8 @@ export function validateSessionProtocolResult(method, result) {
             return validateResult(method, result, sessionProtocolRetryResultSchema);
         case "session.exec":
             return validateResult(method, result, sessionProtocolExecResultSchema);
+        case "session.sample":
+            return validateResult(method, result, sessionProtocolSampleResultSchema);
         case "session.interrupt":
             return validateResult(method, result, sessionProtocolInterruptResultSchema);
     }
@@ -1885,6 +2059,22 @@ function validateExecParams(params) {
         },
     };
 }
+function validateSampleParams(params) {
+    const parsed = sessionProtocolSampleParamsSchema.safeParse(params);
+    if (!parsed.success) {
+        const message = hasIssue(parsed.error, [], "invalid_type")
+            ? "session.sample params must be an object"
+            : hasIssue(parsed.error, ["sessionId"])
+                ? "session.sample params.sessionId must be a non-empty string"
+                : hasIssue(parsed.error, ["context"])
+                    ? "session.sample params.context must include a system prompt and messages"
+                    : hasIssue(parsed.error, ["options"])
+                        ? "session.sample params.options must be an object"
+                        : `session.sample params are invalid: ${formatZodError(parsed.error)}`;
+        return invalidParams(message);
+    }
+    return { ok: true, value: parsed.data };
+}
 function validateSetReasoningParams(params) {
     const parsed = sessionProtocolSetReasoningParamsSchema.safeParse(params);
     if (!parsed.success) {
@@ -2370,24 +2560,6 @@ function invalidParams(message) {
         error: createSessionProtocolError(SESSION_PROTOCOL_ERROR_CODES.invalidParams, message),
     };
 }
-function isMessage(value) {
-    if (!isRecord(value)) {
-        return false;
-    }
-    switch (value.role) {
-        case "user":
-            return typeof value.content === "string" || Array.isArray(value.content);
-        case "assistant":
-            return Array.isArray(value.content);
-        case "toolResult":
-            return (typeof value.toolCallId === "string" &&
-                typeof value.toolName === "string" &&
-                typeof value.isError === "boolean" &&
-                Array.isArray(value.content));
-        default:
-            return false;
-    }
-}
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }