@ai-sdk/harness 1.0.133 → 1.0.134

package/dist/index.js

@@ -1,695 +1,730 @@
-// 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
+import { posix } from "node:path";
+import { AISDKError } from "@ai-sdk/provider";
+//#region src/v1/harness-v1-questions-tool.ts
+const 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()
+});
+const harnessV1QuestionsToolInputSchema = z.object({
+	allowPartialAnswers: z.boolean(),
+	questions: z.array(harnessV1QuestionSchema).min(1)
+});
+const harnessV1QuestionAnswerSchema = z.object({
+	optionIds: z.array(z.string()),
+	freeform: z.string().optional()
+});
+const 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") })
+]);
+const 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: z2.object({ file_path: z2.string() }),
-    outputSchema: z2.unknown()
-  }),
-  write: tool({
-    description: "Write content to a file",
-    inputSchema: z2.object({ file_path: z2.string(), content: z2.string() }),
-    outputSchema: z2.unknown()
-  }),
-  edit: tool({
-    description: "Edit a file by replacing text",
-    inputSchema: z2.object({
-      file_path: z2.string(),
-      old_string: z2.string(),
-      new_string: z2.string()
-    }),
-    outputSchema: z2.unknown()
-  }),
-  bash: tool({
-    description: "Execute a shell command",
-    inputSchema: z2.object({ command: z2.string() }),
-    outputSchema: z2.unknown()
-  }),
-  grep: tool({
-    description: "Search file contents with regex",
-    inputSchema: z2.object({ pattern: z2.string() }),
-    outputSchema: z2.unknown()
-  }),
-  glob: tool({
-    description: "Find files matching a glob pattern",
-    inputSchema: z2.object({ pattern: z2.string() }),
-    outputSchema: z2.unknown()
-  }),
-  webSearch: tool({
-    description: "Search the web",
-    inputSchema: z2.object({ query: z2.string() }),
-    outputSchema: z2.unknown()
-  }),
-  askUserQuestions: harnessV1QuestionsTool
+//#endregion
+//#region src/v1/harness-v1-builtin-tool.ts
+/**
+* Cross-harness vocabulary of common built-in tool names with their baseline
+* input schemas. Adapters that declare a built-in with one of these
+* `commonName`s must accept (at least) every input the baseline schema
+* accepts. Extra optional fields are encouraged.
+*
+* Used both as runtime values (spread into `ToolSet`s for inspection) and as
+* a vocabulary source — `HarnessV1BuiltinToolName` is derived from its keys.
+*/
+const HARNESS_V1_BUILTIN_TOOLS = {
+	read: tool({
+		description: "Read file contents",
+		inputSchema: z.object({ file_path: z.string() }),
+		outputSchema: z.unknown()
+	}),
+	write: tool({
+		description: "Write content to a file",
+		inputSchema: z.object({
+			file_path: z.string(),
+			content: z.string()
+		}),
+		outputSchema: z.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()
+		}),
+		outputSchema: z.unknown()
+	}),
+	bash: tool({
+		description: "Execute a shell command",
+		inputSchema: z.object({ command: z.string() }),
+		outputSchema: z.unknown()
+	}),
+	grep: tool({
+		description: "Search file contents with regex",
+		inputSchema: z.object({ pattern: z.string() }),
+		outputSchema: z.unknown()
+	}),
+	glob: tool({
+		description: "Find files matching a glob pattern",
+		inputSchema: z.object({ pattern: z.string() }),
+		outputSchema: z.unknown()
+	}),
+	webSearch: tool({
+		description: "Search the web",
+		inputSchema: z.object({ query: z.string() }),
+		outputSchema: z.unknown()
+	}),
+	askUserQuestions: harnessV1QuestionsTool
 };
-var HARNESS_V1_BUILTIN_TOOL_NAMES = Object.keys(
-  HARNESS_V1_BUILTIN_TOOLS
-);
+const HARNESS_V1_BUILTIN_TOOL_NAMES = Object.keys(HARNESS_V1_BUILTIN_TOOLS);
+/**
+* Declare a built-in tool that maps to a cross-harness common name. The
+* adapter's input schema must accept every input the standard schema for
+* `commonName` accepts. Extra optional fields are encouraged.
+*
+* If the schema is missing a field the standard requires (or has an
+* incompatible type), the return type collapses to a tagged error tuple,
+* which fails the surrounding `as const satisfies ToolSet` assignment and
+* surfaces a readable TypeScript error at the offending entry.
+*/
 function commonTool(commonName, opts) {
-  return {
-    ...tool({
-      description: opts.description,
-      inputSchema: opts.inputSchema
-    }),
-    nativeName: opts.nativeName,
-    commonName,
-    toolUseKind: opts.toolUseKind
-  };
+	return {
+		...tool({
+			description: opts.description,
+			inputSchema: opts.inputSchema
+		}),
+		nativeName: opts.nativeName,
+		commonName,
+		toolUseKind: opts.toolUseKind
+	};
 }
-
-// src/v1/harness-v1-network-sandbox-session.ts
-import { posix } from "path";
-var HARNESS_V1_STATE_DIRECTORY_NAME = ".ai-sdk-harness";
-function harnessStateDirectoryPath({
-  sandboxHomeDir
-}) {
-  return posix.join(sandboxHomeDir, HARNESS_V1_STATE_DIRECTORY_NAME);
+//#endregion
+//#region src/v1/harness-v1-network-sandbox-session.ts
+/**
+* Fixed directory, relative to the sandbox's own HOME, that holds every
+* piece of state the harness machinery generates.
+*/
+const HARNESS_V1_STATE_DIRECTORY_NAME = ".ai-sdk-harness";
+/**
+* Fixed, non-configurable path for harness-generated state (bootstrap files,
+* markers, and `.agent-runs`) under the sandbox's own HOME, never under
+* {@link HarnessV1NetworkSandboxSession.defaultWorkingDirectory}. Resolve HOME
+* with `resolveSandboxHomeDir` when it is not already known. This works from
+* provider creation hooks that only have a plain sandbox session. The
+* framework also calls this with a symbolic `$HOME` when hashing bootstrap
+* recipes, so changes to the state path invalidate existing templates.
+*/
+function harnessStateDirectoryPath({ sandboxHomeDir }) {
+	return posix.join(sandboxHomeDir, HARNESS_V1_STATE_DIRECTORY_NAME);
 }
-
-// src/v1/harness-session-data-directory-path.ts
-import { posix as posix2 } from "path";
+//#endregion
+//#region src/v1/harness-session-data-directory-path.ts
 function encodeHarnessPathSegment(value) {
-  const encoded = encodeURIComponent(value);
-  if (encoded === "") return "%";
-  if (encoded === ".") return "%2E";
-  if (encoded === "..") return "%2E%2E";
-  return encoded;
+	const encoded = encodeURIComponent(value);
+	if (encoded === "") return "%";
+	if (encoded === ".") return "%2E";
+	if (encoded === "..") return "%2E%2E";
+	return encoded;
 }
-function harnessSessionDataDirectoryPath({
-  stateDirectory,
-  sessionId
-}) {
-  return posix2.join(
-    stateDirectory,
-    ".agent-runs",
-    encodeHarnessPathSegment(sessionId)
-  );
+/**
+* Return the per-session harness state path under `.agent-runs`. Session IDs
+* occupy one encoded path segment, so path separators and parent-directory
+* references cannot move session data outside the harness state directory.
+*/
+function harnessSessionDataDirectoryPath({ stateDirectory, sessionId }) {
+	return posix.join(stateDirectory, ".agent-runs", encodeHarnessPathSegment(sessionId));
 }
-
-// src/v1/harness-v1-stream-part.ts
-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 = z3.record(
-  z3.string(),
-  harnessV1JsonValueSchema
-);
-var harnessV1MetadataSchema = z3.record(
-  z3.string(),
-  z3.record(z3.string(), harnessV1JsonValueSchema)
-);
-var harnessV1ProviderMetadataSchema = z3.record(
-  z3.string(),
-  z3.record(z3.string(), harnessV1JsonValueSchema)
-);
-var harnessV1CallWarningSchema = z3.union([
-  z3.object({
-    type: z3.literal("unsupported-setting"),
-    setting: z3.string(),
-    details: z3.string().optional()
-  }),
-  z3.object({
-    type: z3.literal("unsupported-tool"),
-    tool: z3.string(),
-    details: z3.string().optional()
-  }),
-  z3.object({ type: z3.literal("other"), message: z3.string() })
+//#endregion
+//#region src/v1/harness-v1-stream-part.ts
+const harnessV1JsonValueSchema = z.lazy(() => z.union([
+	z.string(),
+	z.number(),
+	z.boolean(),
+	z.null(),
+	z.array(harnessV1JsonValueSchema),
+	z.record(z.string(), harnessV1JsonValueSchema)
+]));
+const harnessV1ToolResultValueSchema = harnessV1JsonValueSchema;
+const harnessV1JsonObjectSchema = z.record(z.string(), harnessV1JsonValueSchema);
+const harnessV1MetadataSchema = z.record(z.string(), z.record(z.string(), harnessV1JsonValueSchema));
+const harnessV1ProviderMetadataSchema = z.record(z.string(), z.record(z.string(), harnessV1JsonValueSchema));
+const harnessV1CallWarningSchema = z.union([
+	z.object({
+		type: z.literal("unsupported-setting"),
+		setting: z.string(),
+		details: z.string().optional()
+	}),
+	z.object({
+		type: z.literal("unsupported-tool"),
+		tool: z.string(),
+		details: z.string().optional()
+	}),
+	z.object({
+		type: z.literal("other"),
+		message: z.string()
+	})
 ]);
-var harnessV1UsageSchema = z3.object({
-  inputTokens: z3.object({
-    total: z3.number().optional(),
-    noCache: z3.number().optional(),
-    cacheRead: z3.number().optional(),
-    cacheWrite: z3.number().optional()
-  }),
-  outputTokens: z3.object({
-    total: z3.number().optional(),
-    text: z3.number().optional(),
-    reasoning: z3.number().optional()
-  }),
-  raw: harnessV1JsonObjectSchema.optional()
-});
-var harnessV1FinishReasonSchema = z3.object({
-  unified: z3.enum([
-    "stop",
-    "length",
-    "content-filter",
-    "tool-calls",
-    "error",
-    "other"
-  ]),
-  raw: z3.string().optional()
-});
-var harnessV1StreamStartPartSchema = z3.object({
-  type: z3.literal("stream-start"),
-  warnings: z3.array(harnessV1CallWarningSchema).readonly().optional(),
-  modelId: z3.string().optional()
-});
-var harnessV1TextStartPartSchema = z3.object({
-  type: z3.literal("text-start"),
-  id: z3.string(),
-  harnessMetadata: harnessV1MetadataSchema.optional()
-});
-var harnessV1TextDeltaPartSchema = z3.object({
-  type: z3.literal("text-delta"),
-  id: z3.string(),
-  delta: z3.string(),
-  harnessMetadata: harnessV1MetadataSchema.optional()
-});
-var harnessV1TextEndPartSchema = z3.object({
-  type: z3.literal("text-end"),
-  id: z3.string(),
-  harnessMetadata: harnessV1MetadataSchema.optional()
-});
-var harnessV1ReasoningStartPartSchema = z3.object({
-  type: z3.literal("reasoning-start"),
-  id: z3.string(),
-  harnessMetadata: harnessV1MetadataSchema.optional()
-});
-var harnessV1ReasoningDeltaPartSchema = z3.object({
-  type: z3.literal("reasoning-delta"),
-  id: z3.string(),
-  delta: z3.string(),
-  harnessMetadata: harnessV1MetadataSchema.optional()
-});
-var harnessV1ReasoningEndPartSchema = z3.object({
-  type: z3.literal("reasoning-end"),
-  id: z3.string(),
-  harnessMetadata: harnessV1MetadataSchema.optional()
-});
-var harnessV1ToolInputStartPartSchema = z3.object({
-  type: z3.literal("tool-input-start"),
-  id: z3.string(),
-  toolName: z3.string(),
-  providerMetadata: harnessV1ProviderMetadataSchema.optional(),
-  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 = z3.object({
-  type: z3.literal("tool-input-end"),
-  id: z3.string(),
-  providerMetadata: harnessV1ProviderMetadataSchema.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: z3.string().optional(),
-  stepToolCallCount: z3.number().int().positive().optional()
-});
-var harnessV1ToolApprovalRequestPartSchema = z3.object({
-  type: z3.literal("tool-approval-request"),
-  approvalId: z3.string(),
-  toolCallId: z3.string(),
-  providerMetadata: harnessV1ProviderMetadataSchema.optional()
-});
-var harnessV1ToolResultPartSchema = z3.object({
-  type: z3.literal("tool-result"),
-  toolCallId: z3.string(),
-  toolName: z3.string(),
-  result: harnessV1ToolResultValueSchema,
-  isError: z3.boolean().optional(),
-  preliminary: z3.boolean().optional(),
-  dynamic: z3.boolean().optional(),
-  providerMetadata: harnessV1ProviderMetadataSchema.optional()
-});
-var harnessV1FinishStepPartSchema = z3.object({
-  type: z3.literal("finish-step"),
-  finishReason: harnessV1FinishReasonSchema,
-  usage: harnessV1UsageSchema,
-  harnessMetadata: harnessV1MetadataSchema.optional()
-});
-var harnessV1FinishPartSchema = z3.object({
-  type: z3.literal("finish"),
-  finishReason: harnessV1FinishReasonSchema,
-  totalUsage: harnessV1UsageSchema,
-  harnessMetadata: harnessV1MetadataSchema.optional()
-});
-var harnessV1FileChangePartSchema = z3.object({
-  type: z3.literal("file-change"),
-  event: z3.enum(["create", "modify", "delete"]),
-  path: z3.string(),
-  harnessMetadata: harnessV1MetadataSchema.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 = z3.object({
-  type: z3.literal("error"),
-  error: z3.unknown()
-});
-var harnessV1RawPartSchema = z3.object({
-  type: z3.literal("raw"),
-  rawValue: z3.unknown()
-});
-var harnessV1StreamPartSchema = z3.discriminatedUnion("type", [
-  harnessV1StreamStartPartSchema,
-  harnessV1TextStartPartSchema,
-  harnessV1TextDeltaPartSchema,
-  harnessV1TextEndPartSchema,
-  harnessV1ReasoningStartPartSchema,
-  harnessV1ReasoningDeltaPartSchema,
-  harnessV1ReasoningEndPartSchema,
-  harnessV1ToolInputStartPartSchema,
-  harnessV1ToolInputDeltaPartSchema,
-  harnessV1ToolInputEndPartSchema,
-  harnessV1ToolCallPartSchema,
-  harnessV1ToolApprovalRequestPartSchema,
-  harnessV1ToolResultPartSchema,
-  harnessV1FinishStepPartSchema,
-  harnessV1FinishPartSchema,
-  harnessV1FileChangePartSchema,
-  harnessV1CompactionPartSchema,
-  harnessV1ErrorPartSchema,
-  harnessV1RawPartSchema
+const harnessV1UsageSchema = z.object({
+	inputTokens: z.object({
+		total: z.number().optional(),
+		noCache: z.number().optional(),
+		cacheRead: z.number().optional(),
+		cacheWrite: z.number().optional()
+	}),
+	outputTokens: z.object({
+		total: z.number().optional(),
+		text: z.number().optional(),
+		reasoning: z.number().optional()
+	}),
+	raw: harnessV1JsonObjectSchema.optional()
+});
+const harnessV1FinishReasonSchema = z.object({
+	unified: z.enum([
+		"stop",
+		"length",
+		"content-filter",
+		"tool-calls",
+		"error",
+		"other"
+	]),
+	raw: z.string().optional()
+});
+const harnessV1StreamStartPartSchema = z.object({
+	type: z.literal("stream-start"),
+	warnings: z.array(harnessV1CallWarningSchema).readonly().optional(),
+	modelId: z.string().optional()
+});
+const harnessV1TextStartPartSchema = z.object({
+	type: z.literal("text-start"),
+	id: z.string(),
+	harnessMetadata: harnessV1MetadataSchema.optional()
+});
+const harnessV1TextDeltaPartSchema = z.object({
+	type: z.literal("text-delta"),
+	id: z.string(),
+	delta: z.string(),
+	harnessMetadata: harnessV1MetadataSchema.optional()
+});
+const harnessV1TextEndPartSchema = z.object({
+	type: z.literal("text-end"),
+	id: z.string(),
+	harnessMetadata: harnessV1MetadataSchema.optional()
+});
+const harnessV1ReasoningStartPartSchema = z.object({
+	type: z.literal("reasoning-start"),
+	id: z.string(),
+	harnessMetadata: harnessV1MetadataSchema.optional()
+});
+const harnessV1ReasoningDeltaPartSchema = z.object({
+	type: z.literal("reasoning-delta"),
+	id: z.string(),
+	delta: z.string(),
+	harnessMetadata: harnessV1MetadataSchema.optional()
+});
+const harnessV1ReasoningEndPartSchema = z.object({
+	type: z.literal("reasoning-end"),
+	id: z.string(),
+	harnessMetadata: harnessV1MetadataSchema.optional()
+});
+const harnessV1ToolInputStartPartSchema = z.object({
+	type: z.literal("tool-input-start"),
+	id: z.string(),
+	toolName: z.string(),
+	providerMetadata: harnessV1ProviderMetadataSchema.optional(),
+	providerExecuted: z.boolean().optional(),
+	dynamic: z.boolean().optional(),
+	title: z.string().optional()
+});
+const harnessV1ToolInputDeltaPartSchema = z.object({
+	type: z.literal("tool-input-delta"),
+	id: z.string(),
+	delta: z.string(),
+	providerMetadata: harnessV1ProviderMetadataSchema.optional()
+});
+const harnessV1ToolInputEndPartSchema = z.object({
+	type: z.literal("tool-input-end"),
+	id: z.string(),
+	providerMetadata: harnessV1ProviderMetadataSchema.optional()
+});
+const harnessV1ToolCallPartSchema = z.object({
+	type: z.literal("tool-call"),
+	toolCallId: z.string(),
+	toolName: z.string(),
+	input: z.string(),
+	providerExecuted: z.boolean().optional(),
+	dynamic: z.boolean().optional(),
+	providerMetadata: harnessV1ProviderMetadataSchema.optional(),
+	nativeName: z.string().optional(),
+	stepToolCallCount: z.number().int().positive().optional()
+});
+const harnessV1ToolApprovalRequestPartSchema = z.object({
+	type: z.literal("tool-approval-request"),
+	approvalId: z.string(),
+	toolCallId: z.string(),
+	providerMetadata: harnessV1ProviderMetadataSchema.optional()
+});
+const harnessV1ToolResultPartSchema = z.object({
+	type: z.literal("tool-result"),
+	toolCallId: z.string(),
+	toolName: z.string(),
+	result: harnessV1ToolResultValueSchema,
+	isError: z.boolean().optional(),
+	preliminary: z.boolean().optional(),
+	dynamic: z.boolean().optional(),
+	providerMetadata: harnessV1ProviderMetadataSchema.optional()
+});
+const harnessV1FinishStepPartSchema = z.object({
+	type: z.literal("finish-step"),
+	finishReason: harnessV1FinishReasonSchema,
+	usage: harnessV1UsageSchema,
+	harnessMetadata: harnessV1MetadataSchema.optional()
+});
+const harnessV1FinishPartSchema = z.object({
+	type: z.literal("finish"),
+	finishReason: harnessV1FinishReasonSchema,
+	totalUsage: harnessV1UsageSchema,
+	harnessMetadata: harnessV1MetadataSchema.optional()
+});
+const harnessV1FileChangePartSchema = z.object({
+	type: z.literal("file-change"),
+	event: z.enum([
+		"create",
+		"modify",
+		"delete"
+	]),
+	path: z.string(),
+	harnessMetadata: harnessV1MetadataSchema.optional()
+});
+const harnessV1CompactionPartSchema = z.object({
+	type: z.literal("compaction"),
+	trigger: z.enum(["manual", "auto"]),
+	summary: z.string(),
+	tokensBefore: z.number().optional(),
+	tokensAfter: z.number().optional(),
+	harnessMetadata: harnessV1MetadataSchema.optional()
+});
+const harnessV1ErrorPartSchema = z.object({
+	type: z.literal("error"),
+	error: z.unknown()
+});
+const harnessV1RawPartSchema = z.object({
+	type: z.literal("raw"),
+	rawValue: z.unknown()
+});
+/**
+* Assembled discriminated union over every `HarnessV1StreamPart` variant. Left
+* un-annotated so it keeps its precise inferred type — the protocol layer
+* composes the individual member schemas, and the type test asserts the
+* inferred union equals `HarnessV1StreamPart`.
+*/
+const harnessV1StreamPartSchema = z.discriminatedUnion("type", [
+	harnessV1StreamStartPartSchema,
+	harnessV1TextStartPartSchema,
+	harnessV1TextDeltaPartSchema,
+	harnessV1TextEndPartSchema,
+	harnessV1ReasoningStartPartSchema,
+	harnessV1ReasoningDeltaPartSchema,
+	harnessV1ReasoningEndPartSchema,
+	harnessV1ToolInputStartPartSchema,
+	harnessV1ToolInputDeltaPartSchema,
+	harnessV1ToolInputEndPartSchema,
+	harnessV1ToolCallPartSchema,
+	harnessV1ToolApprovalRequestPartSchema,
+	harnessV1ToolResultPartSchema,
+	harnessV1FinishStepPartSchema,
+	harnessV1FinishPartSchema,
+	harnessV1FileChangePartSchema,
+	harnessV1CompactionPartSchema,
+	harnessV1ErrorPartSchema,
+	harnessV1RawPartSchema
 ]);
-
-// src/v1/harness-v1-bridge-protocol.ts
-import { z as z5 } from "zod/v4";
-
-// src/v1/harness-v1-diagnostic.ts
-import { z as z4 } from "zod/v4";
-var harnessV1DebugLevelSchema = z4.enum([
-  "error",
-  "warn",
-  "info",
-  "debug",
-  "trace"
+//#endregion
+//#region src/v1/harness-v1-diagnostic.ts
+/** Severity of a diagnostic, ordered most → least severe. */
+const harnessV1DebugLevelSchema = z.enum([
+	"error",
+	"warn",
+	"info",
+	"debug",
+	"trace"
 ]);
-var harnessV1DebugConfigSchema = z4.object({
-  enabled: z4.boolean().optional(),
-  level: harnessV1DebugLevelSchema.optional(),
-  subsystems: z4.array(z4.string()).optional()
-});
-
-// src/v1/harness-v1-bridge-protocol.ts
-var harnessV1BridgeToolWireSchema = z5.object({
-  name: z5.string(),
-  description: z5.string().optional(),
-  inputSchema: z5.unknown().optional()
-});
-var harnessV1BridgePermissionModeSchema = z5.enum([
-  "allow-reads",
-  "allow-edits",
-  "allow-all"
+/**
+* Per-session diagnostics configuration the framework hands an adapter (and the
+* host sends on `start.debug`). When absent or `enabled` is false the adapter
+* captures and emits nothing. `subsystems` filters structured events by dotted
+* prefix; console capture is independent of the subsystem filter.
+*/
+const harnessV1DebugConfigSchema = z.object({
+	enabled: z.boolean().optional(),
+	level: harnessV1DebugLevelSchema.optional(),
+	subsystems: z.array(z.string()).optional()
+});
+//#endregion
+//#region src/v1/harness-v1-bridge-protocol.ts
+/**
+* The subset of a host-defined tool that travels on the `start` message. The
+* runtime only needs the name, description, and JSON-Schema input to surface
+* the tool; `execute` stays on the host.
+*/
+const harnessV1BridgeToolWireSchema = z.object({
+	name: z.string(),
+	description: z.string().optional(),
+	inputSchema: z.unknown().optional()
+});
+const harnessV1BridgePermissionModeSchema = z.enum([
+	"allow-reads",
+	"allow-edits",
+	"allow-all"
 ]);
-var harnessV1BridgeBuiltinToolFilteringSchema = z5.discriminatedUnion(
-  "mode",
-  [
-    z5.object({
-      mode: z5.literal("allow"),
-      toolNames: z5.array(z5.string())
-    }),
-    z5.object({
-      mode: z5.literal("deny"),
-      toolNames: z5.array(z5.string())
-    })
-  ]
-);
-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()
-  })
+const harnessV1BridgeBuiltinToolFilteringSchema = z.discriminatedUnion("mode", [z.object({
+	mode: z.literal("allow"),
+	toolNames: z.array(z.string())
+}), z.object({
+	mode: z.literal("deny"),
+	toolNames: z.array(z.string())
+})]);
+const harnessV1BridgeResponseFormatSchema = z.discriminatedUnion("type", [z.object({ type: z.literal("text") }), z.object({
+	type: z.literal("json"),
+	schema: z.record(z.string(), z.json()).optional(),
+	name: z.string().optional(),
+	description: z.string().optional()
+})]);
+/**
+* Common fields of the inbound `start` message. Each adapter extends this with
+* its runtime-specific configuration (e.g. `thinking`/`continue` for Claude
+* Code, `reasoningEffort`/`webSearch`/`skills`/`resumeThreadId` for Codex) and
+* assembles the final inbound union from the shared command members below.
+*
+* `debug` carries the general `HarnessV1DebugConfig` — diagnostics config is not
+* a bridge concept, it just happens to ride the `start` frame for bridge-backed
+* adapters.
+*/
+const harnessV1BridgeStartBaseSchema = z.object({
+	type: z.literal("start"),
+	prompt: z.string(),
+	tools: z.array(harnessV1BridgeToolWireSchema).optional(),
+	model: z.string().optional(),
+	debug: harnessV1DebugConfigSchema.optional(),
+	permissionMode: harnessV1BridgePermissionModeSchema.optional(),
+	builtinToolFiltering: harnessV1BridgeBuiltinToolFilteringSchema.optional(),
+	responseFormat: harnessV1BridgeResponseFormatSchema.optional()
+});
+/**
+* Sent the instant the bridge accepts an authenticated WS connection. The host
+* waits for it before sending `start`/`resume`, because some sandbox runtimes
+* complete the upstream WS handshake before the connection is wired through to
+* the bridge process — anything sent in that gap is dropped. Carries the
+* bridge's lifecycle `state` and highest emitted `seq` for reconnect.
+*/
+const harnessV1BridgeHelloSchema = z.object({
+	type: z.literal("bridge-hello"),
+	state: z.string().optional(),
+	lastSeq: z.number().optional(),
+	capabilities: z.object({ experimental_userMessageResponses: z.boolean().optional() }).optional()
+});
+const experimental_harnessV1BridgeUserMessageResponseSchema = z.object({
+	type: z.literal("user-message-response"),
+	messageId: z.string(),
+	accepted: z.boolean(),
+	error: z.object({ message: z.string() }).optional()
+});
+/**
+* The bridge's reply to an inbound `stop`. Carries the adapter-specific
+* payload the host serializes into lifecycle state `data`.
+*/
+const harnessV1BridgeStopSchema = z.object({
+	type: z.literal("bridge-stop"),
+	data: z.unknown()
+});
+/**
+* A resume coordinate the bridge proactively announces (e.g. Codex's thread id)
+* so the host can cache it for a later resume without waiting for `stop`.
+*/
+const harnessV1BridgeThreadSchema = z.object({
+	type: z.literal("bridge-thread"),
+	threadId: z.string()
+});
+/**
+* One captured console line from inside the sandbox. The bridge line-buffers
+* `process.stdout`/`process.stderr` and emits one of these per complete line.
+* Routed host-side to the diagnostics sink, never to the consumer stream.
+*/
+const harnessV1BridgeSandboxLogSchema = z.object({
+	type: z.literal("sandbox-log"),
+	source: z.string(),
+	stream: z.enum(["stdout", "stderr"]),
+	line: z.string()
+});
+/**
+* A structured diagnostic an adapter emits from inside the bridge via
+* `turn.bridgeLog(...)`. Gated by the session's debug level + subsystem filter.
+*/
+const harnessV1BridgeDebugEventSchema = z.object({
+	type: z.literal("debug-event"),
+	level: harnessV1DebugLevelSchema,
+	subsystem: z.string(),
+	message: z.string(),
+	attrs: z.record(z.string(), z.unknown()).optional(),
+	error: z.object({
+		name: z.string().optional(),
+		message: z.string(),
+		stack: z.string().optional()
+	}).optional()
+});
+/**
+* Every frame a bridge can send to the host: the stream-part events plus the
+* transport/control frames. This is the schema the host `SandboxChannel`
+* validates inbound frames against.
+*/
+const harnessV1BridgeOutboundMessageSchema = z.discriminatedUnion("type", [
+	harnessV1StreamStartPartSchema,
+	harnessV1TextStartPartSchema,
+	harnessV1TextDeltaPartSchema,
+	harnessV1TextEndPartSchema,
+	harnessV1ReasoningStartPartSchema,
+	harnessV1ReasoningDeltaPartSchema,
+	harnessV1ReasoningEndPartSchema,
+	harnessV1ToolInputStartPartSchema,
+	harnessV1ToolInputDeltaPartSchema,
+	harnessV1ToolInputEndPartSchema,
+	harnessV1ToolCallPartSchema,
+	harnessV1ToolApprovalRequestPartSchema,
+	harnessV1ToolResultPartSchema,
+	harnessV1FinishStepPartSchema,
+	harnessV1FinishPartSchema,
+	harnessV1FileChangePartSchema,
+	harnessV1CompactionPartSchema,
+	harnessV1ErrorPartSchema,
+	harnessV1RawPartSchema,
+	harnessV1BridgeHelloSchema,
+	experimental_harnessV1BridgeUserMessageResponseSchema,
+	harnessV1BridgeStopSchema,
+	harnessV1BridgeThreadSchema,
+	harnessV1BridgeSandboxLogSchema,
+	harnessV1BridgeDebugEventSchema
 ]);
-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 = 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 = z5.object({
-  type: z5.literal("user-message-response"),
-  messageId: z5.string(),
-  accepted: z5.boolean(),
-  error: z5.object({ message: z5.string() }).optional()
-});
-var harnessV1BridgeStopSchema = z5.object({
-  type: z5.literal("bridge-stop"),
-  data: z5.unknown()
-});
-var harnessV1BridgeThreadSchema = z5.object({
-  type: z5.literal("bridge-thread"),
-  threadId: z5.string()
-});
-var harnessV1BridgeSandboxLogSchema = z5.object({
-  type: z5.literal("sandbox-log"),
-  source: z5.string(),
-  stream: z5.enum(["stdout", "stderr"]),
-  line: z5.string()
-});
-var harnessV1BridgeDebugEventSchema = z5.object({
-  type: z5.literal("debug-event"),
-  level: harnessV1DebugLevelSchema,
-  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 = z5.discriminatedUnion(
-  "type",
-  [
-    harnessV1StreamStartPartSchema,
-    harnessV1TextStartPartSchema,
-    harnessV1TextDeltaPartSchema,
-    harnessV1TextEndPartSchema,
-    harnessV1ReasoningStartPartSchema,
-    harnessV1ReasoningDeltaPartSchema,
-    harnessV1ReasoningEndPartSchema,
-    harnessV1ToolInputStartPartSchema,
-    harnessV1ToolInputDeltaPartSchema,
-    harnessV1ToolInputEndPartSchema,
-    harnessV1ToolCallPartSchema,
-    harnessV1ToolApprovalRequestPartSchema,
-    harnessV1ToolResultPartSchema,
-    harnessV1FinishStepPartSchema,
-    harnessV1FinishPartSchema,
-    harnessV1FileChangePartSchema,
-    harnessV1CompactionPartSchema,
-    harnessV1ErrorPartSchema,
-    harnessV1RawPartSchema,
-    harnessV1BridgeHelloSchema,
-    experimental_harnessV1BridgeUserMessageResponseSchema,
-    harnessV1BridgeStopSchema,
-    harnessV1BridgeThreadSchema,
-    harnessV1BridgeSandboxLogSchema,
-    harnessV1BridgeDebugEventSchema
-  ]
-);
+/**
+* Normalize a bridge diagnostics wire frame into the transport-agnostic
+* `HarnessV1Diagnostic` an adapter reports to the framework. A captured console
+* line maps `stderr` → `warn` and `stdout` → `info`; a structured event passes
+* its fields through. This is the seam where the bridge's serialization is
+* lifted into the general emission shape every harness shares.
+*/
 function harnessV1DiagnosticFromBridgeFrame(frame, context) {
-  if (frame.type === "sandbox-log") {
-    return {
-      level: frame.stream === "stderr" ? "warn" : "info",
-      message: frame.line,
-      subsystem: `sandbox.log.${frame.source}`,
-      kind: "log",
-      source: frame.source,
-      stream: frame.stream,
-      sessionId: context.sessionId,
-      timestamp: context.timestamp
-    };
-  }
-  return {
-    level: frame.level,
-    message: frame.message,
-    subsystem: frame.subsystem,
-    kind: "event",
-    attrs: frame.attrs,
-    error: frame.error,
-    sessionId: context.sessionId,
-    timestamp: context.timestamp
-  };
+	if (frame.type === "sandbox-log") return {
+		level: frame.stream === "stderr" ? "warn" : "info",
+		message: frame.line,
+		subsystem: `sandbox.log.${frame.source}`,
+		kind: "log",
+		source: frame.source,
+		stream: frame.stream,
+		sessionId: context.sessionId,
+		timestamp: context.timestamp
+	};
+	return {
+		level: frame.level,
+		message: frame.message,
+		subsystem: frame.subsystem,
+		kind: "event",
+		attrs: frame.attrs,
+		error: frame.error,
+		sessionId: context.sessionId,
+		timestamp: context.timestamp
+	};
 }
-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: z5.string()
-});
-var harnessV1BridgeAbortInboundSchema = z5.object({
-  type: z5.literal("abort")
-});
-var harnessV1BridgeDestroyInboundSchema = z5.object({
-  type: z5.literal("destroy")
-});
-var harnessV1BridgeResumeInboundSchema = z5.object({
-  type: z5.literal("resume"),
-  lastSeenEventId: z5.number()
-});
-var harnessV1BridgeStopInboundSchema = z5.object({
-  type: z5.literal("stop")
-});
-var harnessV1BridgeInboundCommandSchemas = [
-  harnessV1BridgeToolResultInboundSchema,
-  harnessV1BridgeToolApprovalResponseInboundSchema,
-  harnessV1BridgeUserMessageInboundSchema,
-  harnessV1BridgeAbortInboundSchema,
-  harnessV1BridgeDestroyInboundSchema,
-  harnessV1BridgeResumeInboundSchema,
-  harnessV1BridgeStopInboundSchema
+const harnessV1BridgeToolResultInboundSchema = z.object({
+	type: z.literal("tool-result"),
+	toolCallId: z.string(),
+	output: z.unknown(),
+	isError: z.boolean().optional(),
+	toolResult: z.unknown().optional()
+});
+const harnessV1BridgeToolApprovalResponseInboundSchema = z.object({
+	type: z.literal("tool-approval-response"),
+	approvalId: z.string(),
+	approved: z.boolean(),
+	reason: z.string().optional()
+});
+const harnessV1BridgeUserMessageInboundSchema = z.object({
+	type: z.literal("user-message"),
+	messageId: z.string().optional(),
+	text: z.string()
+});
+const experimental_harnessV1BridgeUserMessageInboundSchema = harnessV1BridgeUserMessageInboundSchema.extend({ messageId: z.string() });
+const harnessV1BridgeAbortInboundSchema = z.object({ type: z.literal("abort") });
+const harnessV1BridgeDestroyInboundSchema = z.object({ type: z.literal("destroy") });
+/**
+* Reconnect: after re-establishing the socket the host asks the bridge to
+* replay every buffered event with `seq > lastSeenEventId`.
+*/
+const harnessV1BridgeResumeInboundSchema = z.object({
+	type: z.literal("resume"),
+	lastSeenEventId: z.number()
+});
+/**
+* The bridge replies with `bridge-stop` carrying any runtime resume data,
+* then exits.
+*/
+const harnessV1BridgeStopInboundSchema = z.object({ type: z.literal("stop") });
+/**
+* The inbound command members shared by every bridge adapter. Spread these
+* alongside the adapter's own `start` schema to build the final inbound union:
+* `z.discriminatedUnion('type', [adapterStartSchema, ...harnessV1BridgeInboundCommandSchemas])`.
+*/
+const harnessV1BridgeInboundCommandSchemas = [
+	harnessV1BridgeToolResultInboundSchema,
+	harnessV1BridgeToolApprovalResponseInboundSchema,
+	harnessV1BridgeUserMessageInboundSchema,
+	harnessV1BridgeAbortInboundSchema,
+	harnessV1BridgeDestroyInboundSchema,
+	harnessV1BridgeResumeInboundSchema,
+	harnessV1BridgeStopInboundSchema
 ];
-var harnessV1BridgeReadySchema = z5.object({
-  type: z5.literal("bridge-ready"),
-  port: z5.number()
-});
-
-// src/v1/harness-v1-tool-filtering.ts
+/**
+* The JSON line the bridge writes to stdout once its WebSocket server is bound,
+* announcing the port the host should connect to.
+*/
+const harnessV1BridgeReadySchema = z.object({
+	type: z.literal("bridge-ready"),
+	port: z.number()
+});
+//#endregion
+//#region src/v1/harness-v1-tool-filtering.ts
 function isHarnessV1BuiltinToolIncluded(input) {
-  if (input.toolFiltering == null) return true;
-  return input.toolFiltering.mode === "allow" ? input.toolFiltering.toolNames.includes(input.toolName) : !input.toolFiltering.toolNames.includes(input.toolName);
+	if (input.toolFiltering == null) return true;
+	return input.toolFiltering.mode === "allow" ? input.toolFiltering.toolNames.includes(input.toolName) : !input.toolFiltering.toolNames.includes(input.toolName);
 }
 function getHarnessV1BuiltinToolFilteringDenialReason(input) {
-  return `Tool '${input.toolName}' is inactive due to the HarnessAgent tool filtering policy.`;
+	return `Tool '${input.toolName}' is inactive due to the HarnessAgent tool filtering policy.`;
 }
-
-// src/errors/harness-error.ts
-import { AISDKError } from "@ai-sdk/provider";
-var name = "AI_HarnessError";
-var marker = `vercel.ai.error.${name}`;
-var symbol = Symbol.for(marker);
-var _a, _b;
-var HarnessError = class extends (_b = AISDKError, _a = symbol, _b) {
-  constructor({ message, cause }) {
-    super({ name, message, cause });
-    this[_a] = true;
-  }
-  static isInstance(error) {
-    return AISDKError.hasMarker(error, marker);
-  }
+//#endregion
+//#region src/errors/harness-error.ts
+const name$3 = "AI_HarnessError";
+const marker$3 = `vercel.ai.error.${name$3}`;
+const symbol$3 = Symbol.for(marker$3);
+/**
+* Base error type for failures originating in or signalled by a harness
+* adapter. Specific failure modes (e.g. unsupported capability) extend this
+* class.
+*/
+var HarnessError = class extends AISDKError {
+	constructor({ message, cause }) {
+		super({
+			name: name$3,
+			message,
+			cause
+		});
+		this[symbol$3] = true;
+	}
+	static isInstance(error) {
+		return AISDKError.hasMarker(error, marker$3);
+	}
 };
-
-// src/errors/harness-capability-unsupported-error.ts
-import { AISDKError as AISDKError2 } from "@ai-sdk/provider";
-var name2 = "AI_HarnessCapabilityUnsupportedError";
-var marker2 = `vercel.ai.error.${name2}`;
-var symbol2 = Symbol.for(marker2);
-var _a2, _b2;
-var HarnessCapabilityUnsupportedError = class extends (_b2 = HarnessError, _a2 = symbol2, _b2) {
-  constructor({
-    message,
-    harnessId,
-    cause
-  }) {
-    super({ message, cause });
-    this[_a2] = true;
-    Object.defineProperty(this, "name", { value: name2 });
-    this.harnessId = harnessId;
-  }
-  static isInstance(error) {
-    return AISDKError2.hasMarker(error, marker2);
-  }
+//#endregion
+//#region src/errors/harness-capability-unsupported-error.ts
+const name$2 = "AI_HarnessCapabilityUnsupportedError";
+const marker$2 = `vercel.ai.error.${name$2}`;
+const symbol$2 = Symbol.for(marker$2);
+/**
+* Thrown when a caller asks the harness to do something the adapter (or the
+* supplied sandbox) does not support, e.g. requesting manual compaction from
+* an adapter that only auto-compacts, or invoking `getPortEndpoint` on a
+* sandbox that does not expose one.
+*
+* The caller supplies the full human-readable message. Optional `harnessId`
+* is recorded as structured context for tooling.
+*/
+var HarnessCapabilityUnsupportedError = class extends HarnessError {
+	constructor({ message, harnessId, cause }) {
+		super({
+			message,
+			cause
+		});
+		this[symbol$2] = true;
+		Object.defineProperty(this, "name", { value: name$2 });
+		this.harnessId = harnessId;
+	}
+	static isInstance(error) {
+		return AISDKError.hasMarker(error, marker$2);
+	}
 };
-
-// src/errors/harness-history-unavailable-error.ts
-import { AISDKError as AISDKError3 } from "@ai-sdk/provider";
-var name3 = "AI_HarnessHistoryUnavailableError";
-var marker3 = `vercel.ai.error.${name3}`;
-var symbol3 = Symbol.for(marker3);
-var _a3, _b3;
-var HarnessHistoryUnavailableError = class extends (_b3 = HarnessError, _a3 = symbol3, _b3) {
-  constructor({
-    message,
-    harnessId,
-    cause
-  }) {
-    super({ message, cause });
-    this[_a3] = true;
-    Object.defineProperty(this, "name", { value: name3 });
-    this.harnessId = harnessId;
-  }
-  static isInstance(error) {
-    return AISDKError3.hasMarker(error, marker3);
-  }
+//#endregion
+//#region src/errors/harness-history-unavailable-error.ts
+const name$1 = "AI_HarnessHistoryUnavailableError";
+const marker$1 = `vercel.ai.error.${name$1}`;
+const symbol$1 = Symbol.for(marker$1);
+/**
+* Thrown by `readHistory` when the adapter supports history reads but cannot
+* reach the runtime's store from the current environment — for example the
+* store lives inside a remote sandbox, or the transcript directory is
+* missing or unreadable.
+*
+* Distinct from `HarnessCapabilityUnsupportedError` (the adapter does not
+* implement history reads at all) so hosts can retry or degrade differently.
+* A conversation with no recorded messages yet is not an error; it resolves
+* to an empty result instead.
+*/
+var HarnessHistoryUnavailableError = class extends HarnessError {
+	constructor({ message, harnessId, cause }) {
+		super({
+			message,
+			cause
+		});
+		this[symbol$1] = true;
+		Object.defineProperty(this, "name", { value: name$1 });
+		this.harnessId = harnessId;
+	}
+	static isInstance(error) {
+		return AISDKError.hasMarker(error, marker$1);
+	}
 };
-
-// src/errors/harness-sandbox-authentication-error.ts
-import { AISDKError as AISDKError4 } from "@ai-sdk/provider";
-var name4 = "AI_HarnessSandboxAuthenticationError";
-var marker4 = `vercel.ai.error.${name4}`;
-var symbol4 = Symbol.for(marker4);
-var _a4, _b4;
-var HarnessSandboxAuthenticationError = class extends (_b4 = HarnessError, _a4 = symbol4, _b4) {
-  constructor({
-    message,
-    sandboxProviderId,
-    cause
-  }) {
-    super({ message, cause });
-    this[_a4] = true;
-    Object.defineProperty(this, "name", { value: name4 });
-    this.sandboxProviderId = sandboxProviderId;
-  }
-  static isInstance(error) {
-    return AISDKError4.hasMarker(error, marker4);
-  }
-};
-export {
-  HARNESS_V1_BUILTIN_TOOLS,
-  HARNESS_V1_BUILTIN_TOOL_NAMES,
-  HarnessCapabilityUnsupportedError,
-  HarnessError,
-  HarnessHistoryUnavailableError,
-  HarnessSandboxAuthenticationError,
-  commonTool,
-  experimental_harnessV1BridgeUserMessageInboundSchema,
-  experimental_harnessV1BridgeUserMessageResponseSchema,
-  getHarnessV1BuiltinToolFilteringDenialReason,
-  harnessSessionDataDirectoryPath,
-  harnessStateDirectoryPath,
-  harnessV1BridgeAbortInboundSchema,
-  harnessV1BridgeBuiltinToolFilteringSchema,
-  harnessV1BridgeDebugEventSchema,
-  harnessV1BridgeDestroyInboundSchema,
-  harnessV1BridgeHelloSchema,
-  harnessV1BridgeInboundCommandSchemas,
-  harnessV1BridgeOutboundMessageSchema,
-  harnessV1BridgePermissionModeSchema,
-  harnessV1BridgeReadySchema,
-  harnessV1BridgeResponseFormatSchema,
-  harnessV1BridgeResumeInboundSchema,
-  harnessV1BridgeSandboxLogSchema,
-  harnessV1BridgeStartBaseSchema,
-  harnessV1BridgeStopInboundSchema,
-  harnessV1BridgeStopSchema,
-  harnessV1BridgeThreadSchema,
-  harnessV1BridgeToolApprovalResponseInboundSchema,
-  harnessV1BridgeToolResultInboundSchema,
-  harnessV1BridgeToolWireSchema,
-  harnessV1BridgeUserMessageInboundSchema,
-  harnessV1DebugConfigSchema,
-  harnessV1DebugLevelSchema,
-  harnessV1DiagnosticFromBridgeFrame,
-  harnessV1ErrorPartSchema,
-  harnessV1FileChangePartSchema,
-  harnessV1FinishPartSchema,
-  harnessV1FinishStepPartSchema,
-  harnessV1QuestionsToolInputSchema,
-  harnessV1QuestionsToolOutputSchema,
-  harnessV1RawPartSchema,
-  harnessV1ReasoningDeltaPartSchema,
-  harnessV1ReasoningEndPartSchema,
-  harnessV1ReasoningStartPartSchema,
-  harnessV1StreamPartSchema,
-  harnessV1StreamStartPartSchema,
-  harnessV1TextDeltaPartSchema,
-  harnessV1TextEndPartSchema,
-  harnessV1TextStartPartSchema,
-  harnessV1ToolApprovalRequestPartSchema,
-  harnessV1ToolCallPartSchema,
-  harnessV1ToolResultPartSchema,
-  isHarnessV1BuiltinToolIncluded
+//#endregion
+//#region src/errors/harness-sandbox-authentication-error.ts
+const name = "AI_HarnessSandboxAuthenticationError";
+const marker = `vercel.ai.error.${name}`;
+const symbol = Symbol.for(marker);
+/**
+* Thrown when a sandbox provider cannot authenticate or authorize the
+* operation needed to create or resume a harness sandbox. Providers should
+* preserve the underlying SDK failure as `cause` and supply a message that
+* explains how the consumer can configure credentials.
+*/
+var HarnessSandboxAuthenticationError = class extends HarnessError {
+	constructor({ message, sandboxProviderId, cause }) {
+		super({
+			message,
+			cause
+		});
+		this[symbol] = true;
+		Object.defineProperty(this, "name", { value: name });
+		this.sandboxProviderId = sandboxProviderId;
+	}
+	static isInstance(error) {
+		return AISDKError.hasMarker(error, marker);
+	}
 };
+//#endregion
+export { HARNESS_V1_BUILTIN_TOOLS, HARNESS_V1_BUILTIN_TOOL_NAMES, HarnessCapabilityUnsupportedError, HarnessError, HarnessHistoryUnavailableError, HarnessSandboxAuthenticationError, commonTool, experimental_harnessV1BridgeUserMessageInboundSchema, experimental_harnessV1BridgeUserMessageResponseSchema, getHarnessV1BuiltinToolFilteringDenialReason, harnessSessionDataDirectoryPath, harnessStateDirectoryPath, harnessV1BridgeAbortInboundSchema, harnessV1BridgeBuiltinToolFilteringSchema, harnessV1BridgeDebugEventSchema, harnessV1BridgeDestroyInboundSchema, harnessV1BridgeHelloSchema, harnessV1BridgeInboundCommandSchemas, harnessV1BridgeOutboundMessageSchema, harnessV1BridgePermissionModeSchema, harnessV1BridgeReadySchema, harnessV1BridgeResponseFormatSchema, harnessV1BridgeResumeInboundSchema, harnessV1BridgeSandboxLogSchema, harnessV1BridgeStartBaseSchema, harnessV1BridgeStopInboundSchema, harnessV1BridgeStopSchema, harnessV1BridgeThreadSchema, harnessV1BridgeToolApprovalResponseInboundSchema, harnessV1BridgeToolResultInboundSchema, harnessV1BridgeToolWireSchema, harnessV1BridgeUserMessageInboundSchema, harnessV1DebugConfigSchema, harnessV1DebugLevelSchema, harnessV1DiagnosticFromBridgeFrame, harnessV1ErrorPartSchema, harnessV1FileChangePartSchema, harnessV1FinishPartSchema, harnessV1FinishStepPartSchema, harnessV1QuestionsToolInputSchema, harnessV1QuestionsToolOutputSchema, harnessV1RawPartSchema, harnessV1ReasoningDeltaPartSchema, harnessV1ReasoningEndPartSchema, harnessV1ReasoningStartPartSchema, harnessV1StreamPartSchema, harnessV1StreamStartPartSchema, harnessV1TextDeltaPartSchema, harnessV1TextEndPartSchema, harnessV1TextStartPartSchema, harnessV1ToolApprovalRequestPartSchema, harnessV1ToolCallPartSchema, harnessV1ToolResultPartSchema, isHarnessV1BuiltinToolIncluded };
+
 //# sourceMappingURL=index.js.map