@markusylisiurunen/tau 0.3.27 → 0.3.29

package/dist/protocol/session_protocol.d.ts

@@ -1,6 +1,8 @@
 import type { AssistantMessage, Message, TextContent, ThinkingContent, Tool, ToolCall } from "@earendil-works/pi-ai";
-export declare const SESSION_PROTOCOL_VERSION: 2;
-export declare const SESSION_PROTOCOL_METHODS: readonly ["initialize", "session.create", "session.list", "session.observe", "session.unobserve", "session.record", "session.submit", "session.queue", "session.steer", "session.cancelPendingMessages", "session.retry", "session.exec", "session.sample", "session.interrupt", "session.snapshot", "session.setReasoning", "session.setPersona", "session.resolvePrompt", "session.autocompletePaths", "session.reload", "session.compact", "session.prune", "session.rewind", "session.terminateSubagent", "session.ephemeral.create", "session.ephemeral.submit", "session.ephemeral.close", "session.clientTool.ack", "session.clientTool.result"];
+export declare const SESSION_PROTOCOL_VERSION: 3;
+export declare const SESSION_PROTOCOL_MAX_EXEC_CAPTURE_BYTES: number;
+export declare const SESSION_PROTOCOL_MAX_EXEC_STDIN_BYTES: number;
+export declare const SESSION_PROTOCOL_METHODS: readonly ["initialize", "session.create", "session.list", "session.observe", "session.unobserve", "session.record", "session.submit", "session.queue", "session.steer", "session.cancelPendingMessages", "session.retry", "session.exec", "session.cancelExec", "session.sample", "session.interrupt", "session.snapshot", "session.setReasoning", "session.setPersona", "session.resolvePrompt", "session.autocompletePaths", "session.reload", "session.compact", "session.prune", "session.rewind", "session.terminateSubagent", "session.ephemeral.create", "session.ephemeral.submit", "session.ephemeral.close", "session.clientTool.ack", "session.clientTool.result"];
 export type SessionProtocolMethod = (typeof SESSION_PROTOCOL_METHODS)[number];
 export declare const SESSION_PROTOCOL_ERROR_CODES: {
     readonly parseError: "parse_error";
@@ -70,9 +72,17 @@ export type SessionProtocolRecordParams = SessionProtocolSessionIdParams & {
 };
 export type SessionProtocolRetryParams = SessionProtocolSessionIdParams;
 export type SessionProtocolExecParams = SessionProtocolSessionIdParams & {
+    execId: string;
     command: string;
+    args?: string[];
+    env?: Record<string, string>;
+    stdinBase64?: string;
     cwd?: string;
     timeoutMs?: number;
+    maxCaptureBytes?: number;
+};
+export type SessionProtocolCancelExecParams = SessionProtocolSessionIdParams & {
+    execId: string;
 };
 export type SessionProtocolSampleContext = {
     systemPrompt: string;
@@ -159,6 +169,7 @@ export type SessionProtocolParamsByMethod = {
     "session.cancelPendingMessages": SessionProtocolCancelPendingMessagesParams;
     "session.retry": SessionProtocolRetryParams;
     "session.exec": SessionProtocolExecParams;
+    "session.cancelExec": SessionProtocolCancelExecParams;
     "session.sample": SessionProtocolSampleParams;
     "session.interrupt": SessionProtocolSessionIdParams;
     "session.snapshot": SessionProtocolSessionIdParams;
@@ -236,6 +247,12 @@ export type SessionProtocolExecResult = {
     stderr: string;
     exitCode: number | null;
     truncated: boolean;
+    timedOut: boolean;
+    aborted: boolean;
+    closeSignal: string | null;
+};
+export type SessionProtocolCancelExecResult = {
+    cancelled: boolean;
 };
 export type SessionProtocolSampleResult = {
     message: AssistantMessage;
@@ -550,6 +567,7 @@ export type SessionProtocolResultByMethod = {
     "session.cancelPendingMessages": SessionProtocolCancelPendingMessagesResult;
     "session.retry": SessionProtocolRetryResult;
     "session.exec": SessionProtocolExecResult;
+    "session.cancelExec": SessionProtocolCancelExecResult;
     "session.sample": SessionProtocolSampleResult;
     "session.interrupt": SessionProtocolInterruptResult;
     "session.snapshot": SessionProtocolSnapshot;
@@ -797,6 +815,7 @@ export declare function validateSessionProtocolParams(method: "session.steer", p
 export declare function validateSessionProtocolParams(method: "session.cancelPendingMessages", params: unknown): SessionProtocolParamsValidationResult<SessionProtocolCancelPendingMessagesParams>;
 export declare function validateSessionProtocolParams(method: "session.retry", params: unknown): SessionProtocolParamsValidationResult<SessionProtocolRetryParams>;
 export declare function validateSessionProtocolParams(method: "session.exec", params: unknown): SessionProtocolParamsValidationResult<SessionProtocolExecParams>;
+export declare function validateSessionProtocolParams(method: "session.cancelExec", params: unknown): SessionProtocolParamsValidationResult<SessionProtocolCancelExecParams>;
 export declare function validateSessionProtocolParams(method: "session.sample", params: unknown): SessionProtocolParamsValidationResult<SessionProtocolSampleParams>;
 export declare function validateSessionProtocolParams(method: "session.interrupt", params: unknown): SessionProtocolParamsValidationResult<SessionProtocolSessionIdParams>;
 export declare function validateSessionProtocolParams(method: "session.snapshot", params: unknown): SessionProtocolParamsValidationResult<SessionProtocolSessionIdParams>;

package/dist/protocol/session_protocol.js

@@ -1,5 +1,7 @@
 import { z } from "zod";
-export const SESSION_PROTOCOL_VERSION = 2;
+export const SESSION_PROTOCOL_VERSION = 3;
+export const SESSION_PROTOCOL_MAX_EXEC_CAPTURE_BYTES = 24 * 1024 * 1024;
+export const SESSION_PROTOCOL_MAX_EXEC_STDIN_BYTES = 16 * 1024 * 1024;
 export const SESSION_PROTOCOL_METHODS = [
     "initialize",
     "session.create",
@@ -13,6 +15,7 @@ export const SESSION_PROTOCOL_METHODS = [
     "session.cancelPendingMessages",
     "session.retry",
     "session.exec",
+    "session.cancelExec",
     "session.sample",
     "session.interrupt",
     "session.snapshot",
@@ -83,6 +86,47 @@ const nonEmptyStringSchema = z
     .refine((value) => value.trim().length > 0);
 const sessionProtocolRequestIdSchema = nonEmptyStringSchema;
 const nullableSessionProtocolRequestIdSchema = sessionProtocolRequestIdSchema.nullable();
+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)
+    .refine((value) => !("HOME" in value), "HOME is controlled by the execution environment");
+const processArgumentsSchema = z
+    .array(z.string())
+    .refine((values) => values.every((value) => !value.includes("\0")));
+const nonEmptyProcessStringSchema = nonEmptyStringSchema.refine((value) => !value.includes("\0"));
+const base64Schema = z.string().refine(isValidBase64, "must be valid base64");
+const boundedExecStdinBase64Schema = base64Schema
+    .max(4 * Math.ceil(SESSION_PROTOCOL_MAX_EXEC_STDIN_BYTES / 3))
+    .refine((value) => decodedBase64ByteLength(value) <= SESSION_PROTOCOL_MAX_EXEC_STDIN_BYTES, "decoded content exceeds maximum size");
+function isValidBase64(value) {
+    if (value.length % 4 !== 0)
+        return false;
+    const padding = value.endsWith("==") ? 2 : value.endsWith("=") ? 1 : 0;
+    const contentLength = value.length - padding;
+    for (let index = 0; index < contentLength; index += 1) {
+        const code = value.charCodeAt(index);
+        const valid = (code >= 65 && code <= 90) ||
+            (code >= 97 && code <= 122) ||
+            (code >= 48 && code <= 57) ||
+            code === 43 ||
+            code === 47;
+        if (!valid)
+            return false;
+    }
+    for (let index = contentLength; index < value.length; index += 1) {
+        if (value.charCodeAt(index) !== 61)
+            return false;
+    }
+    return true;
+}
+function decodedBase64ByteLength(value) {
+    if (!value)
+        return 0;
+    const padding = value.endsWith("==") ? 2 : value.endsWith("=") ? 1 : 0;
+    return (value.length * 3) / 4 - padding;
+}
 const modelTextContentSchema = z
     .object({
     type: z.literal("text"),
@@ -306,9 +350,25 @@ const sessionProtocolRecordParamsSchema = sessionProtocolUserMessageParamsSchema
 const sessionProtocolExecParamsSchema = z
     .object({
     sessionId: nonEmptyStringSchema,
-    command: nonEmptyStringSchema,
-    cwd: nonEmptyStringSchema.optional(),
+    execId: nonEmptyStringSchema,
+    command: nonEmptyProcessStringSchema,
+    args: processArgumentsSchema.optional(),
+    env: environmentVariablesSchema.optional(),
+    stdinBase64: boundedExecStdinBase64Schema.optional(),
+    cwd: nonEmptyProcessStringSchema.optional(),
     timeoutMs: z.number().int().positive().optional(),
+    maxCaptureBytes: z
+        .number()
+        .int()
+        .positive()
+        .max(SESSION_PROTOCOL_MAX_EXEC_CAPTURE_BYTES)
+        .optional(),
+})
+    .strip();
+const sessionProtocolCancelExecParamsSchema = z
+    .object({
+    sessionId: nonEmptyStringSchema,
+    execId: nonEmptyStringSchema,
 })
     .strip();
 const sessionProtocolReasoningEffortSchema = z.enum([
@@ -456,10 +516,6 @@ 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"),
@@ -1257,6 +1313,14 @@ const sessionProtocolExecResultSchema = z
     stderr: z.string(),
     exitCode: z.number().int().nullable(),
     truncated: z.boolean(),
+    timedOut: z.boolean(),
+    aborted: z.boolean(),
+    closeSignal: z.string().nullable(),
+})
+    .strip();
+const sessionProtocolCancelExecResultSchema = z
+    .object({
+    cancelled: z.boolean(),
 })
     .strip();
 const sessionProtocolSampleResultSchema = z
@@ -1868,6 +1932,8 @@ export function validateSessionProtocolParams(method, params) {
             return validateUserMessageParams(method, params);
         case "session.exec":
             return validateExecParams(params);
+        case "session.cancelExec":
+            return validateCancelExecParams(params);
         case "session.sample":
             return validateSampleParams(params);
         case "session.list":
@@ -1959,6 +2025,8 @@ export function validateSessionProtocolResult(method, result) {
             return validateResult(method, result, sessionProtocolRetryResultSchema);
         case "session.exec":
             return validateResult(method, result, sessionProtocolExecResultSchema);
+        case "session.cancelExec":
+            return validateResult(method, result, sessionProtocolCancelExecResultSchema);
         case "session.sample":
             return validateResult(method, result, sessionProtocolSampleResultSchema);
         case "session.interrupt":
@@ -2064,24 +2132,40 @@ function validateExecParams(params) {
             ? "session.exec params must be an object"
             : hasIssue(parsed.error, ["sessionId"])
                 ? "session.exec params.sessionId must be a non-empty string"
-                : hasIssue(parsed.error, ["command"])
-                    ? "session.exec params.command must be a non-empty string"
-                    : hasIssue(parsed.error, ["cwd"])
-                        ? "session.exec params.cwd must be a non-empty string when provided"
-                        : hasIssue(parsed.error, ["timeoutMs"])
-                            ? "session.exec params.timeoutMs must be a positive integer when provided"
-                            : `session.exec params are invalid: ${formatZodError(parsed.error)}`;
+                : hasIssue(parsed.error, ["execId"])
+                    ? "session.exec params.execId must be a non-empty string"
+                    : hasIssue(parsed.error, ["command"])
+                        ? "session.exec params.command must be a non-empty string without null bytes"
+                        : hasIssue(parsed.error, ["args"])
+                            ? "session.exec params.args must be an array of strings without null bytes when provided"
+                            : hasIssue(parsed.error, ["env"])
+                                ? "session.exec params.env must use valid environment variable names and string values without null bytes and cannot override HOME"
+                                : hasIssue(parsed.error, ["stdinBase64"])
+                                    ? `session.exec params.stdinBase64 must be valid base64 encoding at most ${SESSION_PROTOCOL_MAX_EXEC_STDIN_BYTES} bytes`
+                                    : hasIssue(parsed.error, ["cwd"])
+                                        ? "session.exec params.cwd must be a non-empty string without null bytes when provided"
+                                        : hasIssue(parsed.error, ["timeoutMs"])
+                                            ? "session.exec params.timeoutMs must be a positive integer when provided"
+                                            : hasIssue(parsed.error, ["maxCaptureBytes"])
+                                                ? `session.exec params.maxCaptureBytes must be a positive integer no greater than ${SESSION_PROTOCOL_MAX_EXEC_CAPTURE_BYTES} when provided`
+                                                : `session.exec params are invalid: ${formatZodError(parsed.error)}`;
         return invalidParams(message);
     }
-    return {
-        ok: true,
-        value: {
-            sessionId: parsed.data.sessionId,
-            command: parsed.data.command,
-            ...(parsed.data.cwd !== undefined ? { cwd: parsed.data.cwd } : {}),
-            ...(parsed.data.timeoutMs !== undefined ? { timeoutMs: parsed.data.timeoutMs } : {}),
-        },
-    };
+    return { ok: true, value: parsed.data };
+}
+function validateCancelExecParams(params) {
+    const parsed = sessionProtocolCancelExecParamsSchema.safeParse(params);
+    if (!parsed.success) {
+        const message = hasIssue(parsed.error, [], "invalid_type")
+            ? "session.cancelExec params must be an object"
+            : hasIssue(parsed.error, ["sessionId"])
+                ? "session.cancelExec params.sessionId must be a non-empty string"
+                : hasIssue(parsed.error, ["execId"])
+                    ? "session.cancelExec params.execId must be a non-empty string"
+                    : `session.cancelExec params are invalid: ${formatZodError(parsed.error)}`;
+        return invalidParams(message);
+    }
+    return { ok: true, value: parsed.data };
 }
 function validateSampleParams(params) {
     const parsed = sessionProtocolSampleParamsSchema.safeParse(params);
@@ -2371,11 +2455,13 @@ function validateCreateParams(params) {
                     ? "session.create params.executionEnvironment.kind must be 'local', 'cloudflare-sandbox', or 'fly-sprite'"
                     : hasIssue(parsed.error, ["executionEnvironment", "cwd"])
                         ? "session.create params.executionEnvironment.cwd must be an absolute path"
-                        : hasIssue(parsed.error, ["personaId"])
-                            ? "session.create params.personaId must be a non-empty string"
-                            : hasIssue(parsed.error, ["reasoning"])
-                                ? "session.create params.reasoning must be one of none, minimal, low, medium, high, xhigh, or max"
-                                : `session.create params are invalid: ${formatZodError(parsed.error)}`;
+                        : hasIssue(parsed.error, ["executionEnvironment", "env"])
+                            ? "session.create params.executionEnvironment.env must use valid environment variable names and string values without null bytes and cannot override HOME"
+                            : hasIssue(parsed.error, ["personaId"])
+                                ? "session.create params.personaId must be a non-empty string"
+                                : hasIssue(parsed.error, ["reasoning"])
+                                    ? "session.create params.reasoning must be one of none, minimal, low, medium, high, xhigh, or max"
+                                    : `session.create params are invalid: ${formatZodError(parsed.error)}`;
         return invalidParams(message);
     }
     return {