@ai-sdk/harness 1.0.99 → 1.0.101

package/dist/index.js

@@ -1,46 +1,100 @@
 // src/v1/harness-v1-builtin-tool.ts
 import { tool } from "@ai-sdk/provider-utils";
+import { z as z2 } from "zod/v4";
+
+// src/v1/harness-v1-questions-tool.ts
 import { z } from "zod/v4";
+var harnessV1QuestionSchema = z.object({
+  id: z.string().min(1),
+  question: z.string().min(1),
+  header: z.string().optional(),
+  options: z.array(
+    z.object({
+      id: z.string().min(1),
+      label: z.string().min(1),
+      description: z.string().optional(),
+      preview: z.string().optional()
+    })
+  ).optional(),
+  allowMultiple: z.boolean().optional(),
+  allowFreeForm: z.union([
+    z.boolean(),
+    z.object({
+      secret: z.boolean()
+    })
+  ]).optional()
+});
+var harnessV1QuestionsToolInputSchema = z.object({
+  allowPartialAnswers: z.boolean(),
+  questions: z.array(harnessV1QuestionSchema).min(1)
+});
+var harnessV1QuestionAnswerSchema = z.object({
+  optionIds: z.array(z.string()),
+  freeform: z.string().optional()
+});
+var harnessV1QuestionsToolOutputSchema = z.discriminatedUnion(
+  "action",
+  [
+    z.object({
+      action: z.literal("answered"),
+      answers: z.record(z.string(), harnessV1QuestionAnswerSchema)
+    }),
+    z.object({
+      action: z.literal("partially-answered"),
+      answers: z.record(z.string(), harnessV1QuestionAnswerSchema)
+    }),
+    z.object({ action: z.literal("declined") }),
+    z.object({ action: z.literal("cancelled") })
+  ]
+);
+var harnessV1QuestionsTool = {
+  description: "Ask the user one or more questions",
+  inputSchema: harnessV1QuestionsToolInputSchema,
+  outputSchema: harnessV1QuestionsToolOutputSchema
+};
+
+// src/v1/harness-v1-builtin-tool.ts
 var HARNESS_V1_BUILTIN_TOOLS = {
   read: tool({
     description: "Read file contents",
-    inputSchema: z.object({ file_path: z.string() }),
-    outputSchema: z.unknown()
+    inputSchema: z2.object({ file_path: z2.string() }),
+    outputSchema: z2.unknown()
   }),
   write: tool({
     description: "Write content to a file",
-    inputSchema: z.object({ file_path: z.string(), content: z.string() }),
-    outputSchema: z.unknown()
+    inputSchema: z2.object({ file_path: z2.string(), content: z2.string() }),
+    outputSchema: z2.unknown()
   }),
   edit: tool({
     description: "Edit a file by replacing text",
-    inputSchema: z.object({
-      file_path: z.string(),
-      old_string: z.string(),
-      new_string: z.string()
+    inputSchema: z2.object({
+      file_path: z2.string(),
+      old_string: z2.string(),
+      new_string: z2.string()
     }),
-    outputSchema: z.unknown()
+    outputSchema: z2.unknown()
   }),
   bash: tool({
     description: "Execute a shell command",
-    inputSchema: z.object({ command: z.string() }),
-    outputSchema: z.unknown()
+    inputSchema: z2.object({ command: z2.string() }),
+    outputSchema: z2.unknown()
   }),
   grep: tool({
     description: "Search file contents with regex",
-    inputSchema: z.object({ pattern: z.string() }),
-    outputSchema: z.unknown()
+    inputSchema: z2.object({ pattern: z2.string() }),
+    outputSchema: z2.unknown()
   }),
   glob: tool({
     description: "Find files matching a glob pattern",
-    inputSchema: z.object({ pattern: z.string() }),
-    outputSchema: z.unknown()
+    inputSchema: z2.object({ pattern: z2.string() }),
+    outputSchema: z2.unknown()
   }),
   webSearch: tool({
     description: "Search the web",
-    inputSchema: z.object({ query: z.string() }),
-    outputSchema: z.unknown()
-  })
+    inputSchema: z2.object({ query: z2.string() }),
+    outputSchema: z2.unknown()
+  }),
+  askUserQuestions: harnessV1QuestionsTool
 };
 var HARNESS_V1_BUILTIN_TOOL_NAMES = Object.keys(
   HARNESS_V1_BUILTIN_TOOLS
@@ -58,59 +112,59 @@ function commonTool(commonName, opts) {
 }
 
 // src/v1/harness-v1-stream-part.ts
-import { z as z2 } from "zod/v4";
-var harnessV1JsonValueSchema = z2.lazy(
-  () => z2.union([
-    z2.string(),
-    z2.number(),
-    z2.boolean(),
-    z2.null(),
-    z2.array(harnessV1JsonValueSchema),
-    z2.record(z2.string(), harnessV1JsonValueSchema)
+import { z as z3 } from "zod/v4";
+var harnessV1JsonValueSchema = z3.lazy(
+  () => z3.union([
+    z3.string(),
+    z3.number(),
+    z3.boolean(),
+    z3.null(),
+    z3.array(harnessV1JsonValueSchema),
+    z3.record(z3.string(), harnessV1JsonValueSchema)
   ])
 );
 var harnessV1ToolResultValueSchema = harnessV1JsonValueSchema;
-var harnessV1JsonObjectSchema = z2.record(
-  z2.string(),
+var harnessV1JsonObjectSchema = z3.record(
+  z3.string(),
   harnessV1JsonValueSchema
 );
-var harnessV1MetadataSchema = z2.record(
-  z2.string(),
-  z2.record(z2.string(), harnessV1JsonValueSchema)
+var harnessV1MetadataSchema = z3.record(
+  z3.string(),
+  z3.record(z3.string(), harnessV1JsonValueSchema)
 );
-var harnessV1ProviderMetadataSchema = z2.record(
-  z2.string(),
-  z2.record(z2.string(), harnessV1JsonValueSchema)
+var harnessV1ProviderMetadataSchema = z3.record(
+  z3.string(),
+  z3.record(z3.string(), harnessV1JsonValueSchema)
 );
-var harnessV1CallWarningSchema = z2.union([
-  z2.object({
-    type: z2.literal("unsupported-setting"),
-    setting: z2.string(),
-    details: z2.string().optional()
+var harnessV1CallWarningSchema = z3.union([
+  z3.object({
+    type: z3.literal("unsupported-setting"),
+    setting: z3.string(),
+    details: z3.string().optional()
   }),
-  z2.object({
-    type: z2.literal("unsupported-tool"),
-    tool: z2.string(),
-    details: z2.string().optional()
+  z3.object({
+    type: z3.literal("unsupported-tool"),
+    tool: z3.string(),
+    details: z3.string().optional()
   }),
-  z2.object({ type: z2.literal("other"), message: z2.string() })
+  z3.object({ type: z3.literal("other"), message: z3.string() })
 ]);
-var harnessV1UsageSchema = z2.object({
-  inputTokens: z2.object({
-    total: z2.number().optional(),
-    noCache: z2.number().optional(),
-    cacheRead: z2.number().optional(),
-    cacheWrite: z2.number().optional()
+var harnessV1UsageSchema = z3.object({
+  inputTokens: z3.object({
+    total: z3.number().optional(),
+    noCache: z3.number().optional(),
+    cacheRead: z3.number().optional(),
+    cacheWrite: z3.number().optional()
   }),
-  outputTokens: z2.object({
-    total: z2.number().optional(),
-    text: z2.number().optional(),
-    reasoning: z2.number().optional()
+  outputTokens: z3.object({
+    total: z3.number().optional(),
+    text: z3.number().optional(),
+    reasoning: z3.number().optional()
   }),
   raw: harnessV1JsonObjectSchema.optional()
 });
-var harnessV1FinishReasonSchema = z2.object({
-  unified: z2.enum([
+var harnessV1FinishReasonSchema = z3.object({
+  unified: z3.enum([
     "stop",
     "length",
     "content-filter",
@@ -118,127 +172,127 @@ var harnessV1FinishReasonSchema = z2.object({
     "error",
     "other"
   ]),
-  raw: z2.string().optional()
+  raw: z3.string().optional()
 });
-var harnessV1StreamStartPartSchema = z2.object({
-  type: z2.literal("stream-start"),
-  warnings: z2.array(harnessV1CallWarningSchema).readonly().optional(),
-  modelId: z2.string().optional()
+var harnessV1StreamStartPartSchema = z3.object({
+  type: z3.literal("stream-start"),
+  warnings: z3.array(harnessV1CallWarningSchema).readonly().optional(),
+  modelId: z3.string().optional()
 });
-var harnessV1TextStartPartSchema = z2.object({
-  type: z2.literal("text-start"),
-  id: z2.string(),
+var harnessV1TextStartPartSchema = z3.object({
+  type: z3.literal("text-start"),
+  id: z3.string(),
   harnessMetadata: harnessV1MetadataSchema.optional()
 });
-var harnessV1TextDeltaPartSchema = z2.object({
-  type: z2.literal("text-delta"),
-  id: z2.string(),
-  delta: z2.string(),
+var harnessV1TextDeltaPartSchema = z3.object({
+  type: z3.literal("text-delta"),
+  id: z3.string(),
+  delta: z3.string(),
   harnessMetadata: harnessV1MetadataSchema.optional()
 });
-var harnessV1TextEndPartSchema = z2.object({
-  type: z2.literal("text-end"),
-  id: z2.string(),
+var harnessV1TextEndPartSchema = z3.object({
+  type: z3.literal("text-end"),
+  id: z3.string(),
   harnessMetadata: harnessV1MetadataSchema.optional()
 });
-var harnessV1ReasoningStartPartSchema = z2.object({
-  type: z2.literal("reasoning-start"),
-  id: z2.string(),
+var harnessV1ReasoningStartPartSchema = z3.object({
+  type: z3.literal("reasoning-start"),
+  id: z3.string(),
   harnessMetadata: harnessV1MetadataSchema.optional()
 });
-var harnessV1ReasoningDeltaPartSchema = z2.object({
-  type: z2.literal("reasoning-delta"),
-  id: z2.string(),
-  delta: z2.string(),
+var harnessV1ReasoningDeltaPartSchema = z3.object({
+  type: z3.literal("reasoning-delta"),
+  id: z3.string(),
+  delta: z3.string(),
   harnessMetadata: harnessV1MetadataSchema.optional()
 });
-var harnessV1ReasoningEndPartSchema = z2.object({
-  type: z2.literal("reasoning-end"),
-  id: z2.string(),
+var harnessV1ReasoningEndPartSchema = z3.object({
+  type: z3.literal("reasoning-end"),
+  id: z3.string(),
   harnessMetadata: harnessV1MetadataSchema.optional()
 });
-var harnessV1ToolInputStartPartSchema = z2.object({
-  type: z2.literal("tool-input-start"),
-  id: z2.string(),
-  toolName: z2.string(),
+var harnessV1ToolInputStartPartSchema = z3.object({
+  type: z3.literal("tool-input-start"),
+  id: z3.string(),
+  toolName: z3.string(),
   providerMetadata: harnessV1ProviderMetadataSchema.optional(),
-  providerExecuted: z2.boolean().optional(),
-  dynamic: z2.boolean().optional(),
-  title: z2.string().optional()
-});
-var harnessV1ToolInputDeltaPartSchema = z2.object({
-  type: z2.literal("tool-input-delta"),
-  id: z2.string(),
-  delta: z2.string(),
+  providerExecuted: z3.boolean().optional(),
+  dynamic: z3.boolean().optional(),
+  title: z3.string().optional()
+});
+var harnessV1ToolInputDeltaPartSchema = z3.object({
+  type: z3.literal("tool-input-delta"),
+  id: z3.string(),
+  delta: z3.string(),
   providerMetadata: harnessV1ProviderMetadataSchema.optional()
 });
-var harnessV1ToolInputEndPartSchema = z2.object({
-  type: z2.literal("tool-input-end"),
-  id: z2.string(),
+var harnessV1ToolInputEndPartSchema = z3.object({
+  type: z3.literal("tool-input-end"),
+  id: z3.string(),
   providerMetadata: harnessV1ProviderMetadataSchema.optional()
 });
-var harnessV1ToolCallPartSchema = z2.object({
-  type: z2.literal("tool-call"),
-  toolCallId: z2.string(),
-  toolName: z2.string(),
-  input: z2.string(),
-  providerExecuted: z2.boolean().optional(),
-  dynamic: z2.boolean().optional(),
+var harnessV1ToolCallPartSchema = z3.object({
+  type: z3.literal("tool-call"),
+  toolCallId: z3.string(),
+  toolName: z3.string(),
+  input: z3.string(),
+  providerExecuted: z3.boolean().optional(),
+  dynamic: z3.boolean().optional(),
   providerMetadata: harnessV1ProviderMetadataSchema.optional(),
-  nativeName: z2.string().optional(),
-  stepToolCallCount: z2.number().int().positive().optional()
+  nativeName: z3.string().optional(),
+  stepToolCallCount: z3.number().int().positive().optional()
 });
-var harnessV1ToolApprovalRequestPartSchema = z2.object({
-  type: z2.literal("tool-approval-request"),
-  approvalId: z2.string(),
-  toolCallId: z2.string(),
+var harnessV1ToolApprovalRequestPartSchema = z3.object({
+  type: z3.literal("tool-approval-request"),
+  approvalId: z3.string(),
+  toolCallId: z3.string(),
   providerMetadata: harnessV1ProviderMetadataSchema.optional()
 });
-var harnessV1ToolResultPartSchema = z2.object({
-  type: z2.literal("tool-result"),
-  toolCallId: z2.string(),
-  toolName: z2.string(),
+var harnessV1ToolResultPartSchema = z3.object({
+  type: z3.literal("tool-result"),
+  toolCallId: z3.string(),
+  toolName: z3.string(),
   result: harnessV1ToolResultValueSchema,
-  isError: z2.boolean().optional(),
-  preliminary: z2.boolean().optional(),
-  dynamic: z2.boolean().optional(),
+  isError: z3.boolean().optional(),
+  preliminary: z3.boolean().optional(),
+  dynamic: z3.boolean().optional(),
   providerMetadata: harnessV1ProviderMetadataSchema.optional()
 });
-var harnessV1FinishStepPartSchema = z2.object({
-  type: z2.literal("finish-step"),
+var harnessV1FinishStepPartSchema = z3.object({
+  type: z3.literal("finish-step"),
   finishReason: harnessV1FinishReasonSchema,
   usage: harnessV1UsageSchema,
   harnessMetadata: harnessV1MetadataSchema.optional()
 });
-var harnessV1FinishPartSchema = z2.object({
-  type: z2.literal("finish"),
+var harnessV1FinishPartSchema = z3.object({
+  type: z3.literal("finish"),
   finishReason: harnessV1FinishReasonSchema,
   totalUsage: harnessV1UsageSchema,
   harnessMetadata: harnessV1MetadataSchema.optional()
 });
-var harnessV1FileChangePartSchema = z2.object({
-  type: z2.literal("file-change"),
-  event: z2.enum(["create", "modify", "delete"]),
-  path: z2.string(),
+var harnessV1FileChangePartSchema = z3.object({
+  type: z3.literal("file-change"),
+  event: z3.enum(["create", "modify", "delete"]),
+  path: z3.string(),
   harnessMetadata: harnessV1MetadataSchema.optional()
 });
-var harnessV1CompactionPartSchema = z2.object({
-  type: z2.literal("compaction"),
-  trigger: z2.enum(["manual", "auto"]),
-  summary: z2.string(),
-  tokensBefore: z2.number().optional(),
-  tokensAfter: z2.number().optional(),
+var harnessV1CompactionPartSchema = z3.object({
+  type: z3.literal("compaction"),
+  trigger: z3.enum(["manual", "auto"]),
+  summary: z3.string(),
+  tokensBefore: z3.number().optional(),
+  tokensAfter: z3.number().optional(),
   harnessMetadata: harnessV1MetadataSchema.optional()
 });
-var harnessV1ErrorPartSchema = z2.object({
-  type: z2.literal("error"),
-  error: z2.unknown()
+var harnessV1ErrorPartSchema = z3.object({
+  type: z3.literal("error"),
+  error: z3.unknown()
 });
-var harnessV1RawPartSchema = z2.object({
-  type: z2.literal("raw"),
-  rawValue: z2.unknown()
+var harnessV1RawPartSchema = z3.object({
+  type: z3.literal("raw"),
+  rawValue: z3.unknown()
 });
-var harnessV1StreamPartSchema = z2.discriminatedUnion("type", [
+var harnessV1StreamPartSchema = z3.discriminatedUnion("type", [
   harnessV1StreamStartPartSchema,
   harnessV1TextStartPartSchema,
   harnessV1TextDeltaPartSchema,
@@ -261,107 +315,107 @@ var harnessV1StreamPartSchema = z2.discriminatedUnion("type", [
 ]);
 
 // src/v1/harness-v1-bridge-protocol.ts
-import { z as z4 } from "zod/v4";
+import { z as z5 } from "zod/v4";
 
 // src/v1/harness-v1-diagnostic.ts
-import { z as z3 } from "zod/v4";
-var harnessV1DebugLevelSchema = z3.enum([
+import { z as z4 } from "zod/v4";
+var harnessV1DebugLevelSchema = z4.enum([
   "error",
   "warn",
   "info",
   "debug",
   "trace"
 ]);
-var harnessV1DebugConfigSchema = z3.object({
-  enabled: z3.boolean().optional(),
+var harnessV1DebugConfigSchema = z4.object({
+  enabled: z4.boolean().optional(),
   level: harnessV1DebugLevelSchema.optional(),
-  subsystems: z3.array(z3.string()).optional()
+  subsystems: z4.array(z4.string()).optional()
 });
 
 // src/v1/harness-v1-bridge-protocol.ts
-var harnessV1BridgeToolWireSchema = z4.object({
-  name: z4.string(),
-  description: z4.string().optional(),
-  inputSchema: z4.unknown().optional()
+var harnessV1BridgeToolWireSchema = z5.object({
+  name: z5.string(),
+  description: z5.string().optional(),
+  inputSchema: z5.unknown().optional()
 });
-var harnessV1BridgePermissionModeSchema = z4.enum([
+var harnessV1BridgePermissionModeSchema = z5.enum([
   "allow-reads",
   "allow-edits",
   "allow-all"
 ]);
-var harnessV1BridgeBuiltinToolFilteringSchema = z4.discriminatedUnion(
+var harnessV1BridgeBuiltinToolFilteringSchema = z5.discriminatedUnion(
   "mode",
   [
-    z4.object({
-      mode: z4.literal("allow"),
-      toolNames: z4.array(z4.string())
+    z5.object({
+      mode: z5.literal("allow"),
+      toolNames: z5.array(z5.string())
     }),
-    z4.object({
-      mode: z4.literal("deny"),
-      toolNames: z4.array(z4.string())
+    z5.object({
+      mode: z5.literal("deny"),
+      toolNames: z5.array(z5.string())
     })
   ]
 );
-var harnessV1BridgeResponseFormatSchema = z4.discriminatedUnion("type", [
-  z4.object({ type: z4.literal("text") }),
-  z4.object({
-    type: z4.literal("json"),
-    schema: z4.record(z4.string(), z4.json()).optional(),
-    name: z4.string().optional(),
-    description: z4.string().optional()
+var harnessV1BridgeResponseFormatSchema = z5.discriminatedUnion("type", [
+  z5.object({ type: z5.literal("text") }),
+  z5.object({
+    type: z5.literal("json"),
+    schema: z5.record(z5.string(), z5.json()).optional(),
+    name: z5.string().optional(),
+    description: z5.string().optional()
   })
 ]);
-var harnessV1BridgeStartBaseSchema = z4.object({
-  type: z4.literal("start"),
-  prompt: z4.string(),
-  tools: z4.array(harnessV1BridgeToolWireSchema).optional(),
-  model: z4.string().optional(),
+var harnessV1BridgeStartBaseSchema = z5.object({
+  type: z5.literal("start"),
+  prompt: z5.string(),
+  tools: z5.array(harnessV1BridgeToolWireSchema).optional(),
+  model: z5.string().optional(),
   debug: harnessV1DebugConfigSchema.optional(),
   permissionMode: harnessV1BridgePermissionModeSchema.optional(),
   builtinToolFiltering: harnessV1BridgeBuiltinToolFilteringSchema.optional(),
   responseFormat: harnessV1BridgeResponseFormatSchema.optional()
 });
-var harnessV1BridgeHelloSchema = z4.object({
-  type: z4.literal("bridge-hello"),
-  state: z4.string().optional(),
-  lastSeq: z4.number().optional(),
-  capabilities: z4.object({
-    experimental_userMessageResponses: z4.boolean().optional()
+var harnessV1BridgeHelloSchema = z5.object({
+  type: z5.literal("bridge-hello"),
+  state: z5.string().optional(),
+  lastSeq: z5.number().optional(),
+  capabilities: z5.object({
+    experimental_userMessageResponses: z5.boolean().optional()
   }).optional()
 });
-var experimental_harnessV1BridgeUserMessageResponseSchema = z4.object({
-  type: z4.literal("user-message-response"),
-  messageId: z4.string(),
-  accepted: z4.boolean(),
-  error: z4.object({ message: z4.string() }).optional()
+var experimental_harnessV1BridgeUserMessageResponseSchema = z5.object({
+  type: z5.literal("user-message-response"),
+  messageId: z5.string(),
+  accepted: z5.boolean(),
+  error: z5.object({ message: z5.string() }).optional()
 });
-var harnessV1BridgeStopSchema = z4.object({
-  type: z4.literal("bridge-stop"),
-  data: z4.unknown()
+var harnessV1BridgeStopSchema = z5.object({
+  type: z5.literal("bridge-stop"),
+  data: z5.unknown()
 });
-var harnessV1BridgeThreadSchema = z4.object({
-  type: z4.literal("bridge-thread"),
-  threadId: z4.string()
+var harnessV1BridgeThreadSchema = z5.object({
+  type: z5.literal("bridge-thread"),
+  threadId: z5.string()
 });
-var harnessV1BridgeSandboxLogSchema = z4.object({
-  type: z4.literal("sandbox-log"),
-  source: z4.string(),
-  stream: z4.enum(["stdout", "stderr"]),
-  line: z4.string()
+var harnessV1BridgeSandboxLogSchema = z5.object({
+  type: z5.literal("sandbox-log"),
+  source: z5.string(),
+  stream: z5.enum(["stdout", "stderr"]),
+  line: z5.string()
 });
-var harnessV1BridgeDebugEventSchema = z4.object({
-  type: z4.literal("debug-event"),
+var harnessV1BridgeDebugEventSchema = z5.object({
+  type: z5.literal("debug-event"),
   level: harnessV1DebugLevelSchema,
-  subsystem: z4.string(),
-  message: z4.string(),
-  attrs: z4.record(z4.string(), z4.unknown()).optional(),
-  error: z4.object({
-    name: z4.string().optional(),
-    message: z4.string(),
-    stack: z4.string().optional()
+  subsystem: z5.string(),
+  message: z5.string(),
+  attrs: z5.record(z5.string(), z5.unknown()).optional(),
+  error: z5.object({
+    name: z5.string().optional(),
+    message: z5.string(),
+    stack: z5.string().optional()
   }).optional()
 });
-var harnessV1BridgeOutboundMessageSchema = z4.discriminatedUnion(
+var harnessV1BridgeOutboundMessageSchema = z5.discriminatedUnion(
   "type",
   [
     harnessV1StreamStartPartSchema,
@@ -415,38 +469,39 @@ function harnessV1DiagnosticFromBridgeFrame(frame, context) {
     timestamp: context.timestamp
   };
 }
-var harnessV1BridgeToolResultInboundSchema = z4.object({
-  type: z4.literal("tool-result"),
-  toolCallId: z4.string(),
-  output: z4.unknown(),
-  isError: z4.boolean().optional()
-});
-var harnessV1BridgeToolApprovalResponseInboundSchema = z4.object({
-  type: z4.literal("tool-approval-response"),
-  approvalId: z4.string(),
-  approved: z4.boolean(),
-  reason: z4.string().optional()
-});
-var harnessV1BridgeUserMessageInboundSchema = z4.object({
-  type: z4.literal("user-message"),
-  messageId: z4.string().optional(),
-  text: z4.string()
+var harnessV1BridgeToolResultInboundSchema = z5.object({
+  type: z5.literal("tool-result"),
+  toolCallId: z5.string(),
+  output: z5.unknown(),
+  isError: z5.boolean().optional(),
+  toolResult: z5.unknown().optional()
+});
+var harnessV1BridgeToolApprovalResponseInboundSchema = z5.object({
+  type: z5.literal("tool-approval-response"),
+  approvalId: z5.string(),
+  approved: z5.boolean(),
+  reason: z5.string().optional()
+});
+var harnessV1BridgeUserMessageInboundSchema = z5.object({
+  type: z5.literal("user-message"),
+  messageId: z5.string().optional(),
+  text: z5.string()
 });
 var experimental_harnessV1BridgeUserMessageInboundSchema = harnessV1BridgeUserMessageInboundSchema.extend({
-  messageId: z4.string()
+  messageId: z5.string()
 });
-var harnessV1BridgeAbortInboundSchema = z4.object({
-  type: z4.literal("abort")
+var harnessV1BridgeAbortInboundSchema = z5.object({
+  type: z5.literal("abort")
 });
-var harnessV1BridgeDestroyInboundSchema = z4.object({
-  type: z4.literal("destroy")
+var harnessV1BridgeDestroyInboundSchema = z5.object({
+  type: z5.literal("destroy")
 });
-var harnessV1BridgeResumeInboundSchema = z4.object({
-  type: z4.literal("resume"),
-  lastSeenEventId: z4.number()
+var harnessV1BridgeResumeInboundSchema = z5.object({
+  type: z5.literal("resume"),
+  lastSeenEventId: z5.number()
 });
-var harnessV1BridgeStopInboundSchema = z4.object({
-  type: z4.literal("stop")
+var harnessV1BridgeStopInboundSchema = z5.object({
+  type: z5.literal("stop")
 });
 var harnessV1BridgeInboundCommandSchemas = [
   harnessV1BridgeToolResultInboundSchema,
@@ -457,9 +512,9 @@ var harnessV1BridgeInboundCommandSchemas = [
   harnessV1BridgeResumeInboundSchema,
   harnessV1BridgeStopInboundSchema
 ];
-var harnessV1BridgeReadySchema = z4.object({
-  type: z4.literal("bridge-ready"),
-  port: z4.number()
+var harnessV1BridgeReadySchema = z5.object({
+  type: z5.literal("bridge-ready"),
+  port: z5.number()
 });
 
 // src/v1/harness-v1-tool-filtering.ts
@@ -567,6 +622,8 @@ export {
   harnessV1FileChangePartSchema,
   harnessV1FinishPartSchema,
   harnessV1FinishStepPartSchema,
+  harnessV1QuestionsToolInputSchema,
+  harnessV1QuestionsToolOutputSchema,
   harnessV1RawPartSchema,
   harnessV1ReasoningDeltaPartSchema,
   harnessV1ReasoningEndPartSchema,