@markusylisiurunen/tau 0.3.33 → 0.3.35

package/dist/protocol/session_protocol.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-export const SESSION_PROTOCOL_VERSION = 4;
+export const SESSION_PROTOCOL_VERSION = 6;
 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 = [
@@ -19,6 +19,9 @@ export const SESSION_PROTOCOL_METHODS = [
     "session.sample",
     "session.interrupt",
     "session.snapshot",
+    "session.startGoal",
+    "session.resumeGoal",
+    "session.clearGoal",
     "session.setReasoning",
     "session.setPersona",
     "session.resolvePrompt",
@@ -26,7 +29,7 @@ export const SESSION_PROTOCOL_METHODS = [
     "session.reload",
     "session.compact",
     "session.rewind",
-    "session.terminateSubagent",
+    "session.interruptSubagent",
     "session.ephemeral.create",
     "session.ephemeral.submit",
     "session.ephemeral.close",
@@ -345,6 +348,12 @@ const sessionProtocolUserMessageParamsSchema = z
     historyEntryId: nonEmptyStringSchema.optional(),
 })
     .strip();
+const sessionProtocolStartGoalParamsSchema = z
+    .object({
+    sessionId: nonEmptyStringSchema,
+    objective: nonEmptyStringSchema,
+})
+    .strip();
 const sessionProtocolSteerParamsSchema = z
     .object({
     sessionId: nonEmptyStringSchema,
@@ -453,7 +462,7 @@ const sessionProtocolRewindParamsSchema = z
     historyEntryId: nonEmptyStringSchema,
 })
     .strip();
-const sessionProtocolTerminateSubagentParamsSchema = z
+const sessionProtocolInterruptSubagentParamsSchema = z
     .object({
     sessionId: nonEmptyStringSchema,
     subagentId: nonEmptyStringSchema,
@@ -825,25 +834,86 @@ const sessionProtocolAgentUsageSchema = z
     contextWindow: z.number().finite(),
 })
     .strip();
+const sessionProtocolAgentFailedRunFailureSchema = z.discriminatedUnion("kind", [
+    z
+        .object({
+        kind: z.enum(["auto-compaction-failed", "model-subturn-limit", "runtime-error"]),
+        message: z.string(),
+    })
+        .strip(),
+    z
+        .object({
+        kind: z.literal("provider-error"),
+        message: z.string(),
+        stopReason: z.string(),
+    })
+        .strip(),
+]);
+const sessionProtocolAgentInterruptedRunFailureSchema = z
+    .object({
+    kind: z.literal("interrupted"),
+    message: z.string(),
+})
+    .strip();
+const sessionProtocolAgentRunStateBaseSchema = z.object({
+    revision: z.number().int().positive(),
+    startedAt: z.number().finite(),
+    interruptRequested: z.boolean(),
+});
+const sessionProtocolAgentRunStateSchema = z.discriminatedUnion("status", [
+    sessionProtocolAgentRunStateBaseSchema.extend({ status: z.literal("running") }).strip(),
+    sessionProtocolAgentRunStateBaseSchema
+        .extend({
+        status: z.literal("succeeded"),
+        finishedAt: z.number().finite(),
+        response: z.string(),
+    })
+        .strip(),
+    sessionProtocolAgentRunStateBaseSchema
+        .extend({
+        status: z.literal("failed"),
+        finishedAt: z.number().finite(),
+        failure: sessionProtocolAgentFailedRunFailureSchema,
+    })
+        .strip(),
+    sessionProtocolAgentRunStateBaseSchema
+        .extend({
+        status: z.literal("interrupted"),
+        finishedAt: z.number().finite(),
+        failure: sessionProtocolAgentInterruptedRunFailureSchema,
+    })
+        .strip(),
+]);
 const sessionProtocolAgentRunSchema = z
     .object({
     id: nonEmptyStringSchema,
     name: nonEmptyStringSchema,
     title: nonEmptyStringSchema,
-    status: z.enum(["running", "succeeded", "failed", "cancelled"]),
-    modelLabel: z.string().optional(),
+    availability: z.enum(["running", "idle"]),
+    model: z
+        .object({
+        provider: nonEmptyStringSchema,
+        id: nonEmptyStringSchema,
+        reasoning: sessionProtocolReasoningEffortSchema,
+    })
+        .strip(),
+    workingDirectory: nonEmptyStringSchema,
+    createdAt: z.number().finite(),
+    run: sessionProtocolAgentRunStateSchema,
     costTotal: z.number().finite(),
-    turns: z.number().finite(),
-    toolCalls: z.number().finite(),
     usage: sessionProtocolAgentUsageSchema,
-    startedAt: z.number().finite(),
-    finishedAt: z.number().finite().optional(),
-    abortRequested: z.boolean(),
-    progress: z.string().optional(),
-    finalText: z.string().optional(),
-    error: z.string().optional(),
 })
-    .strip();
+    .strip()
+    .superRefine((agent, ctx) => {
+    const running = agent.run.status === "running";
+    if ((agent.availability === "running") !== running) {
+        ctx.addIssue({
+            code: "custom",
+            path: ["availability"],
+            message: "agent availability must match latest run status",
+        });
+    }
+});
 const sessionProtocolFacetSubjectSchema = z.discriminatedUnion("type", [
     z.object({ type: z.literal("session") }).strip(),
     z.object({ type: z.literal("message"), id: nonEmptyStringSchema }).strip(),
@@ -860,6 +930,12 @@ const sessionProtocolFacetSchema = z
     data: z.record(z.string(), z.unknown()),
 })
     .strip();
+const sessionProtocolGoalSchema = z
+    .object({
+    objective: nonEmptyStringSchema,
+    status: z.enum(["active", "blocked"]),
+})
+    .strip();
 const sessionProtocolAgentStateSnapshotSchema = z
     .object({
     revision: z.number().int().nonnegative(),
@@ -880,6 +956,7 @@ const sessionProtocolSnapshotSchema = z
     revision: z.number().int().positive(),
     agentState: sessionProtocolAgentStateSnapshotSchema,
     lifecycle: sessionProtocolSessionLifecycleSchema,
+    goal: sessionProtocolGoalSchema.nullable(),
     costTotal: z.number().nonnegative(),
     settings: sessionProtocolSettingsSnapshotSchema,
     bootstrap: sessionProtocolBootstrapSnapshotSchema,
@@ -1077,6 +1154,7 @@ const sessionProtocolDeltaReasonSchema = z.enum([
     "agent-run",
     "maintenance",
     "configuration",
+    "goal",
     "recovery",
 ]);
 const sessionProtocolChangeSchema = z.discriminatedUnion("type", [
@@ -1092,6 +1170,12 @@ const sessionProtocolChangeSchema = z.discriminatedUnion("type", [
         lifecycle: sessionProtocolSessionLifecycleSchema,
     })
         .strip(),
+    z
+        .object({
+        type: z.literal("goal.set"),
+        goal: sessionProtocolGoalSchema.nullable(),
+    })
+        .strip(),
     z
         .object({
         type: z.literal("cost.set"),
@@ -1332,11 +1416,13 @@ const sessionProtocolSubmitResultSchema = z
     .strip();
 const sessionProtocolTurnResultSchema = sessionProtocolSubmitResultSchema;
 const sessionProtocolRetryResultSchema = sessionProtocolTurnResultSchema;
+const sessionProtocolResumeGoalResultSchema = sessionProtocolTurnResultSchema;
 const sessionProtocolSubmitWithUserResultSchema = sessionProtocolTurnResultSchema
     .extend({
     userHistoryEntryId: nonEmptyStringSchema,
 })
     .strip();
+const sessionProtocolStartGoalResultSchema = sessionProtocolSubmitWithUserResultSchema;
 const sessionProtocolCancelPendingMessagesResultSchema = z
     .object({
     cancelled: z.array(sessionProtocolPendingUserMessageSchema),
@@ -1426,7 +1512,7 @@ const sessionProtocolUnobserveResultSchema = z
     unobserved: z.literal(true),
 })
     .strip();
-const sessionProtocolTerminateSubagentResultSchema = z
+const sessionProtocolInterruptSubagentResultSchema = z
     .object({
     found: z.boolean(),
 })
@@ -1566,6 +1652,9 @@ export function applySessionProtocolDelta(snapshot, message) {
             case "lifecycle.set":
                 next.lifecycle = change.lifecycle;
                 break;
+            case "goal.set":
+                next.goal = structuredClone(change.goal);
+                break;
             case "cost.set":
                 next.costTotal = change.costTotal;
                 break;
@@ -1643,6 +1732,7 @@ function validateAppliedSnapshotChanges(previous, snapshot, changes) {
 function changeCanInvalidateSnapshot(snapshot, change) {
     switch (change.type) {
         case "lifecycle.set":
+        case "goal.set":
         case "cost.set":
         case "settings.set":
         case "agent.set":
@@ -2051,8 +2141,12 @@ export function validateSessionProtocolParams(method, params) {
         case "session.retry":
         case "session.interrupt":
         case "session.snapshot":
+        case "session.resumeGoal":
+        case "session.clearGoal":
         case "session.reload":
             return validateSessionIdParams(method, params);
+        case "session.startGoal":
+            return validateStartGoalParams(params);
         case "session.setReasoning":
             return validateSetReasoningParams(params);
         case "session.setPersona":
@@ -2065,8 +2159,8 @@ export function validateSessionProtocolParams(method, params) {
             return validateCompactParams(params);
         case "session.rewind":
             return validateRewindParams(params);
-        case "session.terminateSubagent":
-            return validateTerminateSubagentParams(params);
+        case "session.interruptSubagent":
+            return validateInterruptSubagentParams(params);
         case "session.ephemeral.create":
             return validateEphemeralCreateParams(params);
         case "session.ephemeral.submit":
@@ -2088,6 +2182,7 @@ export function validateSessionProtocolResult(method, result) {
         case "session.observe":
             return validateResult(method, result, sessionProtocolObserveResultSchema);
         case "session.snapshot":
+        case "session.clearGoal":
         case "session.setPersona":
             return validateResult(method, result, sessionProtocolSnapshotSchema);
         case "session.setReasoning":
@@ -2104,8 +2199,8 @@ export function validateSessionProtocolResult(method, result) {
             return validateResult(method, result, sessionProtocolCompactResultSchema);
         case "session.rewind":
             return validateResult(method, result, sessionProtocolRewindResultSchema);
-        case "session.terminateSubagent":
-            return validateResult(method, result, sessionProtocolTerminateSubagentResultSchema);
+        case "session.interruptSubagent":
+            return validateResult(method, result, sessionProtocolInterruptSubagentResultSchema);
         case "session.ephemeral.create":
             return validateResult(method, result, sessionProtocolEphemeralCreateResultSchema);
         case "session.ephemeral.submit":
@@ -2122,6 +2217,10 @@ export function validateSessionProtocolResult(method, result) {
         case "session.queue":
         case "session.steer":
             return validateResult(method, result, sessionProtocolSubmitWithUserResultSchema);
+        case "session.startGoal":
+            return validateResult(method, result, sessionProtocolStartGoalResultSchema);
+        case "session.resumeGoal":
+            return validateResult(method, result, sessionProtocolResumeGoalResultSchema);
         case "session.cancelPendingMessages":
             return validateResult(method, result, sessionProtocolCancelPendingMessagesResultSchema);
         case "session.record":
@@ -2205,6 +2304,20 @@ function validateUserMessageParams(method, params) {
         },
     };
 }
+function validateStartGoalParams(params) {
+    const parsed = sessionProtocolStartGoalParamsSchema.safeParse(params);
+    if (!parsed.success) {
+        const message = hasIssue(parsed.error, [], "invalid_type")
+            ? "session.startGoal params must be an object"
+            : hasIssue(parsed.error, ["sessionId"])
+                ? "session.startGoal params.sessionId must be a non-empty string"
+                : hasIssue(parsed.error, ["objective"])
+                    ? "session.startGoal params.objective must be a non-empty string"
+                    : `session.startGoal params are invalid: ${formatZodError(parsed.error)}`;
+        return invalidParams(message);
+    }
+    return { ok: true, value: parsed.data };
+}
 function validateSteerParams(params) {
     const parsed = sessionProtocolSteerParamsSchema.safeParse(params);
     if (!parsed.success) {
@@ -2428,16 +2541,16 @@ function validateRewindParams(params) {
         },
     };
 }
-function validateTerminateSubagentParams(params) {
-    const parsed = sessionProtocolTerminateSubagentParamsSchema.safeParse(params);
+function validateInterruptSubagentParams(params) {
+    const parsed = sessionProtocolInterruptSubagentParamsSchema.safeParse(params);
     if (!parsed.success) {
         const message = hasIssue(parsed.error, [], "invalid_type")
-            ? "session.terminateSubagent params must be an object"
+            ? "session.interruptSubagent params must be an object"
             : hasIssue(parsed.error, ["sessionId"])
-                ? "session.terminateSubagent params.sessionId must be a non-empty string"
+                ? "session.interruptSubagent params.sessionId must be a non-empty string"
                 : hasIssue(parsed.error, ["subagentId"])
-                    ? "session.terminateSubagent params.subagentId must be a non-empty string"
-                    : `session.terminateSubagent params are invalid: ${formatZodError(parsed.error)}`;
+                    ? "session.interruptSubagent params.subagentId must be a non-empty string"
+                    : `session.interruptSubagent params are invalid: ${formatZodError(parsed.error)}`;
         return invalidParams(message);
     }
     return {