@hachej/boring-agent 0.1.110 → 0.2.0

package/dist/chunk-72KT6VWV.js

@@ -1,1338 +0,0 @@
-import {
-  safeRandomUUID
-} from "./chunk-YGRQ4Q5P.js";
-import {
-  AgentConsumptionErrorCode,
-  AgentDefinitionErrorCode,
-  AgentDeploymentErrorCode,
-  ErrorCode
-} from "./chunk-KJIEMSQP.js";
-
-// src/shared/skill-resource.ts
-var AGENT_RESOURCES_FILESYSTEM_ID = "agent_resources";
-var AGENT_KNOWLEDGE_FILESYSTEM_ID = "agent_knowledge";
-
-// src/shared/workspace.ts
-var READONLY_FILESYSTEM_MUTATION_CODE = "readonly";
-var RUNTIME_FILESYSTEM_CAPABILITIES = Object.freeze([
-  "read",
-  "write",
-  "create-child",
-  "delete",
-  "move-from"
-]);
-var ReadonlyFilesystemMutationError = class extends Error {
-  code = READONLY_FILESYSTEM_MUTATION_CODE;
-  statusCode = 403;
-  filesystem;
-  operation;
-  constructor(filesystem, operation) {
-    super(`${filesystem} binding is readonly`);
-    this.name = "ReadonlyFilesystemMutationError";
-    this.filesystem = filesystem;
-    this.operation = operation;
-  }
-};
-function isReadonlyFilesystemMutationError(value) {
-  if (!value || typeof value !== "object") return false;
-  const candidate = value;
-  return candidate.code === READONLY_FILESYSTEM_MUTATION_CODE && candidate.statusCode === 403 && typeof candidate.filesystem === "string" && RUNTIME_FILESYSTEM_CAPABILITIES.includes(candidate.operation);
-}
-
-// src/shared/channel.ts
-var descriptors = [
-  {
-    id: "web",
-    label: "Web",
-    icon: "globe",
-    sessionsReadOnlyInWorkspace: false,
-    dialect: "passthrough",
-    canOriginateIdentity: true
-  },
-  {
-    id: "whatsapp",
-    label: "WhatsApp",
-    icon: "message-circle",
-    sessionsReadOnlyInWorkspace: true,
-    dialect: "whatsapp/markdown",
-    canOriginateIdentity: true
-  }
-];
-var CHANNEL_DESCRIPTORS = new Map(
-  descriptors.map((descriptor) => [descriptor.id, Object.freeze(descriptor)])
-);
-function channelDescriptor(originChannel = "web") {
-  return CHANNEL_DESCRIPTORS.get(originChannel);
-}
-
-// src/shared/config-schema.ts
-import { z } from "zod";
-var RuntimeModeSchema = z.enum(["direct", "local", "blaxel", "vercel-sandbox"]);
-var ConfigSchema = z.object({
-  workspaceRoot: z.string(),
-  workspaceId: z.string(),
-  port: z.number().int().positive(),
-  mode: RuntimeModeSchema,
-  model: z.string().optional(),
-  noOpen: z.boolean(),
-  noGitignore: z.boolean(),
-  dev: z.boolean(),
-  verbose: z.boolean()
-});
-var EnvSchema = z.object({
-  BORING_AGENT_MODE: RuntimeModeSchema.optional(),
-  BORING_AGENT_WORKSPACE_ROOT: z.string().optional(),
-  BORING_AGENT_PORT: z.coerce.number().int().positive().optional(),
-  BORING_AGENT_TEMPLATE_PATH: z.string().optional(),
-  BORING_AGENT_VERBOSE: z.enum(["0", "1"]).optional(),
-  BORING_AGENT_MODEL: z.string().optional(),
-  BORING_AGENT_DEFAULT_MODEL: z.string().optional(),
-  BORING_AGENT_DEFAULT_MODEL_PROVIDER: z.string().optional(),
-  BORING_AGENT_DEFAULT_MODEL_ID: z.string().optional(),
-  BORING_AGENT_INFOMANIAK_PROVIDER: z.string().optional(),
-  BORING_AGENT_INFOMANIAK_PRODUCT_ID: z.string().optional(),
-  BORING_AGENT_INFOMANIAK_BASE_URL: z.string().url().optional(),
-  BORING_AGENT_INFOMANIAK_MODEL: z.string().optional(),
-  BORING_AGENT_INFOMANIAK_MODEL_NAME: z.string().optional(),
-  BORING_AGENT_INFOMANIAK_API_KEY_ENV: z.string().optional(),
-  BORING_AGENT_INFOMANIAK_API_KEY: z.string().optional(),
-  BORING_AGENT_CUSTOM_MODEL_PROVIDER: z.string().optional(),
-  BORING_AGENT_CUSTOM_MODEL_ID: z.string().optional(),
-  BORING_AGENT_CUSTOM_MODEL_NAME: z.string().optional(),
-  BORING_AGENT_CUSTOM_MODEL_BASE_URL: z.string().url().optional(),
-  BORING_AGENT_CUSTOM_MODEL_API_KEY_ENV: z.string().optional(),
-  BORING_AGENT_CUSTOM_MODEL_API_KEY: z.string().optional(),
-  BORING_AGENT_CONFIG: z.string().optional(),
-  BORING_AGENT_DEV: z.enum(["0", "1"]).optional(),
-  BORING_AGENT_NO_OPEN: z.enum(["0", "1"]).optional(),
-  BORING_AGENT_NO_GITIGNORE: z.enum(["0", "1"]).optional(),
-  BORING_AGENT_SNAPSHOT_KEEP: z.coerce.number().int().nonnegative().optional(),
-  BORING_AGENT_PYTHON_PACKAGES: z.string().optional(),
-  VERCEL_OIDC_TOKEN: z.string().optional(),
-  VERCEL_ACCESS_TOKEN: z.string().optional(),
-  VERCEL_TOKEN: z.string().optional(),
-  VERCEL_TEAM_ID: z.string().optional(),
-  VERCEL_PROJECT_ID: z.string().optional(),
-  BORING_AGENT_VERCEL_SANDBOX_TIMEOUT_MS: z.coerce.number().int().positive().optional(),
-  BL_WORKSPACE: z.string().optional(),
-  BL_API_KEY: z.string().optional(),
-  BORING_BLAXEL_IMAGE: z.string().optional(),
-  BORING_BLAXEL_MEMORY_MB: z.coerce.number().int().positive().optional(),
-  BORING_BLAXEL_REGION: z.string().optional(),
-  BORING_BLAXEL_VOLUME_SIZE_MB: z.coerce.number().int().positive().optional(),
-  BORING_BLAXEL_TTL: z.string().optional(),
-  BORING_BLAXEL_IDLE_TTL: z.string().optional(),
-  BORING_BLAXEL_TERMINATED_RETENTION: z.string().optional()
-});
-function validateConfig(config) {
-  return ConfigSchema.parse(config);
-}
-
-// src/shared/capabilities.ts
-var DEFAULT_AGENT_RUNTIME_CAPABILITIES = {
-  nativeFollowUp: false,
-  aiSdkOwnsHistory: true
-};
-var PI_AGENT_RUNTIME_CAPABILITIES = {
-  nativeFollowUp: true,
-  aiSdkOwnsHistory: false
-};
-
-// src/shared/agent-definition.ts
-import { z as z3 } from "zod";
-
-// src/shared/digest.ts
-function toHex(bytes) {
-  return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
-}
-async function digestBytes(bytes) {
-  const hash = await globalThis.crypto.subtle.digest("SHA-256", new Uint8Array(bytes));
-  return `sha256:${toHex(new Uint8Array(hash))}`;
-}
-async function sha256(value) {
-  return digestBytes(new TextEncoder().encode(value));
-}
-async function sha256Bytes(bytes) {
-  return digestBytes(bytes);
-}
-function canonicalStringify(value) {
-  if (value === null || typeof value !== "object") {
-    const encoded = JSON.stringify(value);
-    if (encoded === void 0) throw new TypeError("Cannot canonicalize undefined");
-    return encoded;
-  }
-  if (Array.isArray(value)) return `[${value.map(canonicalStringify).join(",")}]`;
-  const record = value;
-  return `{${Object.keys(record).filter((key) => record[key] !== void 0).sort().map((key) => `${JSON.stringify(key)}:${canonicalStringify(record[key])}`).join(",")}}`;
-}
-
-// src/shared/schema-issue.ts
-import { z as z2 } from "zod";
-function formatPath(path) {
-  if (path.length === 0) return "<root>";
-  return path.reduce(
-    (result, part) => typeof part === "number" ? `${result}[${part}]` : result.length === 0 ? String(part) : `${result}.${String(part)}`,
-    ""
-  );
-}
-function mapZodIssues(issues, invalidCode, unsupportedCode) {
-  return issues.flatMap((issue) => {
-    if (issue.code === z2.ZodIssueCode.unrecognized_keys) {
-      const parent = formatPath(issue.path);
-      return [...issue.keys].sort().map((key) => ({
-        code: unsupportedCode,
-        field: parent === "<root>" ? key : `${parent}.${key}`,
-        message: `${key} is not supported by schema version 1`
-      }));
-    }
-    const field = formatPath(issue.path);
-    return [{
-      code: invalidCode,
-      field,
-      message: field === "<root>" ? issue.message : `${field} ${issue.message}`
-    }];
-  });
-}
-var SchemaValidationError = class extends Error {
-  code = ErrorCode.enum.CONFIG_INVALID;
-  field;
-  validationCode;
-  constructor(issue) {
-    super(issue.message);
-    this.field = issue.field;
-    this.validationCode = issue.code;
-  }
-};
-
-// src/shared/agent-definition.ts
-var SHA256_DIGEST_RE = /^sha256:[a-f0-9]{64}$/;
-function hasWellFormedUnicode(value) {
-  for (let index = 0; index < value.length; index += 1) {
-    const code = value.charCodeAt(index);
-    if (code >= 55296 && code <= 56319) {
-      if (index + 1 >= value.length) return false;
-      const next = value.charCodeAt(index + 1);
-      if (next < 56320 || next > 57343) return false;
-      index += 1;
-    } else if (code >= 56320 && code <= 57343) {
-      return false;
-    }
-  }
-  return true;
-}
-function isOpaqueRef(value) {
-  return hasWellFormedUnicode(value) && value.trim() === value && !/[\0-\x1f\x7f]/.test(value);
-}
-function isSafeAssetPath(value) {
-  const segments = value.split("/");
-  return hasWellFormedUnicode(value) && value.normalize("NFC") === value && !/[\0-\x1f\x7f]/.test(value) && !value.includes("\\") && !value.startsWith("/") && !/^[A-Za-z]:[\\/]/.test(value) && !value.startsWith("./") && segments.every((segment) => segment !== "" && segment !== "." && segment !== "..");
-}
-var OpaqueRefSchema = z3.string().min(1, "must be a non-empty reference").max(256, "must be at most 256 characters").refine(isOpaqueRef, "must be a non-empty reference");
-var ReferenceArraySchema = z3.array(OpaqueRefSchema).superRefine((refs, ctx) => {
-  const seen = /* @__PURE__ */ new Set();
-  refs.forEach((ref, index) => {
-    if (seen.has(ref)) {
-      ctx.addIssue({
-        code: z3.ZodIssueCode.custom,
-        path: [index],
-        message: "must not contain duplicate references"
-      });
-    }
-    seen.add(ref);
-  });
-});
-var LABEL_MAX_LENGTH = 128;
-var DESCRIPTION_MAX_LENGTH = 1024;
-function isSafeDisplayText(value) {
-  return hasWellFormedUnicode(value) && value.trim() === value && !/[\0-\x1f\x7f-\x9f\u061c\u200e\u200f\u2028\u2029\u202a-\u202e\u2066-\u2069]/.test(value);
-}
-var LabelSchema = z3.string().min(1, "must not be empty").max(LABEL_MAX_LENGTH, `must be at most ${LABEL_MAX_LENGTH} characters`).refine(isSafeDisplayText, "must be trimmed and contain no control characters");
-var DescriptionSchema = z3.string().min(1, "must not be empty").max(DESCRIPTION_MAX_LENGTH, `must be at most ${DESCRIPTION_MAX_LENGTH} characters`).refine(isSafeDisplayText, "must be trimmed and contain no control characters");
-var SafeAssetPathSchema = z3.string().min(1).refine(isSafeAssetPath, "must be a safe relative asset path");
-var Sha256DigestSchema = z3.string().regex(SHA256_DIGEST_RE, "must be a lowercase sha256 digest").transform((value) => value);
-var AgentDefinitionInputSchema = z3.object({
-  schemaVersion: z3.literal(1),
-  definitionId: OpaqueRefSchema,
-  version: OpaqueRefSchema,
-  label: LabelSchema.optional(),
-  description: DescriptionSchema.optional(),
-  instructionsRef: SafeAssetPathSchema,
-  // Empty legacy arrays remain parseable only so old declarative directories
-  // fail with a targeted migration error when they still select behavior.
-  capabilityRequirements: ReferenceArraySchema.optional(),
-  toolRefs: ReferenceArraySchema.optional(),
-  skillRefs: ReferenceArraySchema.optional(),
-  mcpServerRefs: ReferenceArraySchema.optional()
-}).strict();
-var LEGACY_REFERENCE_FIELDS = [
-  "capabilityRequirements",
-  "toolRefs",
-  "skillRefs",
-  "mcpServerRefs"
-];
-var AgentDefinitionReferenceSchema = z3.object({
-  definitionId: OpaqueRefSchema,
-  version: OpaqueRefSchema,
-  digest: Sha256DigestSchema
-}).strict();
-var AgentDeploymentSchema = z3.object({
-  deploymentId: OpaqueRefSchema,
-  version: OpaqueRefSchema,
-  agentId: OpaqueRefSchema,
-  definition: AgentDefinitionReferenceSchema
-}).strict();
-var AgentDefinitionDigestAssetSchema = z3.object({
-  path: SafeAssetPathSchema,
-  digest: Sha256DigestSchema,
-  content: z3.string().refine(hasWellFormedUnicode, "must contain well-formed Unicode")
-}).strict();
-function validateAgentDefinition(raw) {
-  const result = AgentDefinitionInputSchema.safeParse(raw);
-  if (!result.success) {
-    return {
-      valid: false,
-      issues: mapZodIssues(
-        result.error.issues,
-        AgentDefinitionErrorCode.enum.AGENT_DEFINITION_INVALID,
-        AgentDefinitionErrorCode.enum.AGENT_DEFINITION_UNSUPPORTED_FIELD
-      )
-    };
-  }
-  for (const field of LEGACY_REFERENCE_FIELDS) {
-    if ((result.data[field]?.length ?? 0) > 0) {
-      return {
-        valid: false,
-        issues: [{
-          code: AgentDefinitionErrorCode.enum.AUTHORED_AGENT_REFERENCE_UNSUPPORTED,
-          field,
-          message: `${field} cannot select behavior; configure trusted host plugins instead`
-        }]
-      };
-    }
-  }
-  return {
-    valid: true,
-    value: {
-      schemaVersion: result.data.schemaVersion,
-      definitionId: result.data.definitionId,
-      version: result.data.version,
-      ...result.data.label === void 0 ? {} : { label: result.data.label },
-      ...result.data.description === void 0 ? {} : { description: result.data.description },
-      instructionsRef: result.data.instructionsRef
-    }
-  };
-}
-function validateAgentDeployment(raw) {
-  const result = AgentDeploymentSchema.safeParse(raw);
-  if (!result.success) {
-    return {
-      valid: false,
-      issues: mapZodIssues(
-        result.error.issues,
-        AgentDeploymentErrorCode.enum.AGENT_DEPLOYMENT_INVALID,
-        AgentDeploymentErrorCode.enum.AGENT_DEPLOYMENT_UNSUPPORTED_FIELD
-      )
-    };
-  }
-  return { valid: true, value: result.data };
-}
-async function createAgentAssetDigest(content) {
-  if (!hasWellFormedUnicode(content)) {
-    throw new AgentDefinitionValidationError({
-      code: AgentDefinitionErrorCode.enum.AGENT_DEFINITION_INVALID,
-      field: "content",
-      message: "content must contain well-formed Unicode"
-    });
-  }
-  return sha256(content);
-}
-var AgentDefinitionValidationError = class extends SchemaValidationError {
-  constructor(issue) {
-    super(issue);
-    this.name = "AgentDefinitionValidationError";
-  }
-};
-var AgentDeploymentValidationError = class extends SchemaValidationError {
-  constructor(issue) {
-    super(issue);
-    this.name = "AgentDeploymentValidationError";
-  }
-};
-async function validatedDefinitionAssets(definition, assets) {
-  if (!Array.isArray(assets)) {
-    throw new AgentDefinitionValidationError({
-      code: AgentDefinitionErrorCode.enum.AGENT_DEFINITION_INVALID,
-      field: "assets",
-      message: "assets must be an array"
-    });
-  }
-  const canonicalAssets = [];
-  for (const [index, input] of assets.entries()) {
-    const result = AgentDefinitionDigestAssetSchema.safeParse(input);
-    if (!result.success) {
-      const issue = mapZodIssues(
-        result.error.issues,
-        AgentDefinitionErrorCode.enum.AGENT_DEFINITION_INVALID,
-        AgentDefinitionErrorCode.enum.AGENT_DEFINITION_UNSUPPORTED_FIELD
-      )[0];
-      throw new AgentDefinitionValidationError({
-        ...issue,
-        field: `assets[${index}].${issue.field}`
-      });
-    }
-    if (await createAgentAssetDigest(result.data.content) !== result.data.digest) {
-      throw new AgentDefinitionValidationError({
-        code: AgentDefinitionErrorCode.enum.AGENT_DEFINITION_INVALID,
-        field: "assets.digest",
-        message: `asset digest does not match UTF-8 content: ${result.data.path}`
-      });
-    }
-    canonicalAssets.push(result.data);
-  }
-  canonicalAssets.sort(
-    (left, right) => left.path < right.path ? -1 : left.path > right.path ? 1 : 0
-  );
-  for (let index = 1; index < canonicalAssets.length; index += 1) {
-    if (canonicalAssets[index - 1].path === canonicalAssets[index].path) {
-      throw new AgentDefinitionValidationError({
-        code: AgentDefinitionErrorCode.enum.AGENT_DEFINITION_INVALID,
-        field: "assets.path",
-        message: `duplicate asset path: ${canonicalAssets[index].path}`
-      });
-    }
-  }
-  if (!canonicalAssets.some((asset) => asset.path === definition.instructionsRef)) {
-    throw new AgentDefinitionValidationError({
-      code: AgentDefinitionErrorCode.enum.AGENT_DEFINITION_INVALID,
-      field: "instructionsRef",
-      message: "instructionsRef must name an included verified asset"
-    });
-  }
-  return canonicalAssets;
-}
-async function createAgentDefinitionDigest(input) {
-  const validated = validateAgentDefinition(input.definition);
-  if (!validated.valid) throw new AgentDefinitionValidationError(validated.issues[0]);
-  const assets = await validatedDefinitionAssets(validated.value, input.assets);
-  return sha256(canonicalStringify({ definition: validated.value, assets }));
-}
-async function createAgentDeploymentDigest(deployment) {
-  const validated = validateAgentDeployment(deployment);
-  if (!validated.valid) throw new AgentDeploymentValidationError(validated.issues[0]);
-  return sha256(canonicalStringify(validated.value));
-}
-
-// src/shared/validateTool.ts
-function validateTool(tool) {
-  if (typeof tool !== "object" || tool === null) return null;
-  const t = tool;
-  if (typeof t.name !== "string" || t.name.length === 0) return null;
-  if (typeof t.description !== "string") return null;
-  if (typeof t.parameters !== "object" || t.parameters === null) return null;
-  if (typeof t.execute !== "function") return null;
-  return t;
-}
-
-// src/shared/agent-consumption.ts
-import { z as z4 } from "zod";
-var nonEmptyString = z4.string().min(1);
-function isOpaqueLocatorId(value) {
-  return value.trim() === value && !/[\0-\x1f\x7f]/.test(value) && !value.includes("/") && !value.includes("\\") && !value.includes(":") && value !== "." && value !== "..";
-}
-var OpaqueLocatorIdSchema = z4.string().min(1, "must be a non-empty opaque id").max(256, "must be at most 256 characters").refine(isOpaqueLocatorId, 'must be an opaque platform-owned id (no path separators, scheme, or "..")');
-var TASK_STATES = [
-  "submitted",
-  "working",
-  "input-required",
-  "completed",
-  "failed",
-  "canceled",
-  "rejected"
-];
-var TaskStateSchema = z4.enum(TASK_STATES);
-var TASK_TRANSITIONS = {
-  submitted: ["working", "rejected", "canceled"],
-  working: ["input-required", "completed", "failed", "canceled", "rejected"],
-  "input-required": ["working", "canceled"],
-  completed: [],
-  failed: [],
-  canceled: [],
-  rejected: []
-};
-function isValidTaskTransition(from, to) {
-  return TASK_TRANSITIONS[from].includes(to);
-}
-function assertValidTransition(from, to) {
-  if (!isValidTaskTransition(from, to)) {
-    throw new AgentConsumptionValidationError({
-      code: AgentConsumptionErrorCode.enum.AGENT_CONSUMPTION_INVALID_TRANSITION,
-      field: "state",
-      message: `invalid task state transition: '${from}' -> '${to}'`
-    });
-  }
-}
-var PrincipalRefSchema = z4.object({
-  userId: nonEmptyString,
-  workspaceId: nonEmptyString
-}).strict();
-var AgentRefSchema = z4.object({
-  agentId: nonEmptyString,
-  deploymentId: nonEmptyString.optional()
-}).strict();
-function agentRefEquals(a, b) {
-  return a.agentId === b.agentId && (a.deploymentId ?? null) === (b.deploymentId ?? null);
-}
-var ARTIFACT_LOCATOR_KINDS = ["workspace-file"];
-var WorkspaceFileLocatorSchema = z4.object({
-  kind: z4.literal("workspace-file"),
-  workspaceId: OpaqueLocatorIdSchema,
-  fileId: OpaqueLocatorIdSchema,
-  digest: Sha256DigestSchema
-}).strict();
-var ArtifactLocatorSchema = z4.discriminatedUnion("kind", [WorkspaceFileLocatorSchema]);
-var ArtifactRefSchema = z4.object({
-  artifactId: nonEmptyString,
-  name: z4.string().optional(),
-  mimeType: nonEmptyString,
-  locator: ArtifactLocatorSchema
-}).strict();
-var PartSchema = z4.discriminatedUnion("type", [
-  z4.object({ type: z4.literal("text"), text: z4.string() }).strict(),
-  z4.object({ type: z4.literal("file"), file: ArtifactRefSchema }).strict(),
-  z4.object({ type: z4.literal("data"), mimeType: nonEmptyString, data: z4.unknown() }).strict()
-]);
-var AgentMessageSchema = z4.object({
-  role: z4.enum(["consumer", "agent"]),
-  parts: z4.array(PartSchema),
-  ts: nonEmptyString
-}).strict();
-var AGENT_TASK_SCHEMA_VERSION = "2";
-var AgentTaskSchema = z4.object({
-  id: nonEmptyString,
-  contextId: nonEmptyString,
-  state: TaskStateSchema,
-  messages: z4.array(AgentMessageSchema),
-  artifacts: z4.array(ArtifactRefSchema),
-  principal: PrincipalRefSchema,
-  actor: AgentRefSchema.optional(),
-  schemaVersion: z4.literal(AGENT_TASK_SCHEMA_VERSION),
-  createdAt: nonEmptyString,
-  updatedAt: nonEmptyString
-}).strict();
-function schemaMismatchIssues(issues) {
-  return issues.map((issue) => {
-    const field = formatPath(issue.path);
-    return {
-      code: AgentConsumptionErrorCode.enum.AGENT_CONSUMPTION_SCHEMA_MISMATCH,
-      field,
-      message: field === "<root>" ? issue.message : `${field} ${issue.message}`
-    };
-  });
-}
-function validateAgentTask(raw) {
-  const result = AgentTaskSchema.safeParse(raw);
-  if (!result.success) {
-    return { valid: false, issues: schemaMismatchIssues(result.error.issues) };
-  }
-  return { valid: true, value: result.data };
-}
-var AgentConsumptionValidationError = class extends SchemaValidationError {
-  constructor(issue) {
-    super(issue);
-    this.name = "AgentConsumptionValidationError";
-  }
-};
-var LegacyArtifactRefSchema = z4.object({
-  artifactId: nonEmptyString,
-  name: z4.string().optional(),
-  mimeType: nonEmptyString,
-  uri: nonEmptyString
-}).strict();
-var LegacyPartSchema = z4.discriminatedUnion("type", [
-  z4.object({ type: z4.literal("text"), text: z4.string() }).strict(),
-  z4.object({ type: z4.literal("file"), file: LegacyArtifactRefSchema }).strict(),
-  z4.object({ type: z4.literal("data"), mimeType: nonEmptyString, data: z4.unknown() }).strict()
-]);
-var LegacyAgentMessageSchema = z4.object({
-  role: z4.enum(["consumer", "agent"]),
-  parts: z4.array(LegacyPartSchema),
-  ts: nonEmptyString
-}).strict();
-var LegacyAgentTaskSchema = z4.object({
-  id: nonEmptyString,
-  contextId: nonEmptyString,
-  state: TaskStateSchema,
-  messages: z4.array(LegacyAgentMessageSchema),
-  artifacts: z4.array(LegacyArtifactRefSchema),
-  principal: PrincipalRefSchema,
-  actor: AgentRefSchema.optional(),
-  schemaVersion: z4.literal("1"),
-  createdAt: nonEmptyString,
-  updatedAt: nonEmptyString
-}).strict();
-function collectLegacyArtifactUris(raw) {
-  const uris = [];
-  for (const artifact of raw.artifacts) uris.push(artifact.uri);
-  for (const message of raw.messages) {
-    for (const part of message.parts) {
-      if (part.type === "file") uris.push(part.file.uri);
-    }
-  }
-  return uris;
-}
-function parseAgentTaskEdgeCompat(raw) {
-  const v2 = AgentTaskSchema.safeParse(raw);
-  if (v2.success) return { valid: true, value: v2.data };
-  const legacy = LegacyAgentTaskSchema.safeParse(raw);
-  if (legacy.success) {
-    const uris = collectLegacyArtifactUris(legacy.data);
-    const issues = uris.length > 0 ? uris.map((uri, index) => ({
-      code: AgentConsumptionErrorCode.enum.AGENT_CONSUMPTION_LEGACY_ARTIFACT_REJECTED,
-      field: `artifacts[${index}].uri`,
-      message: `schemaVersion '1' artifact uri '${uri}' has no typed ArtifactLocator translation and is refused before any storage/network effect`
-    })) : [
-      {
-        code: AgentConsumptionErrorCode.enum.AGENT_CONSUMPTION_LEGACY_ARTIFACT_REJECTED,
-        field: "schemaVersion",
-        message: "schemaVersion '1' is no longer accepted; publish schemaVersion '2' with a typed ArtifactLocator"
-      }
-    ];
-    return { valid: false, issues };
-  }
-  return { valid: false, issues: schemaMismatchIssues(v2.error.issues) };
-}
-var ConsumptionGuardsSchema = z4.object({
-  maxDepth: z4.number().int().positive(),
-  inputRequiredTimeoutMs: z4.number().int().positive()
-}).strict();
-function validateConsumptionGuards(raw) {
-  const result = ConsumptionGuardsSchema.safeParse(raw);
-  if (!result.success) {
-    return { valid: false, issues: schemaMismatchIssues(result.error.issues) };
-  }
-  return { valid: true, value: result.data };
-}
-function detectConsumptionCycle(chain, next) {
-  return chain.some((ref) => agentRefEquals(ref, next));
-}
-function assertNoConsumptionCycle(chain, next) {
-  if (detectConsumptionCycle(chain, next)) {
-    const label = next.deploymentId ? `${next.agentId}@${next.deploymentId}` : next.agentId;
-    throw new AgentConsumptionValidationError({
-      code: AgentConsumptionErrorCode.enum.AGENT_CONSUMPTION_CYCLE_DETECTED,
-      field: "actor",
-      message: `consumption cycle detected: agent '${label}' already present in the delegation chain`
-    });
-  }
-}
-function isWithinConsumptionDepth(chain, guards) {
-  return chain.length < guards.maxDepth;
-}
-function assertWithinConsumptionDepth(chain, guards) {
-  if (!isWithinConsumptionDepth(chain, guards)) {
-    throw new AgentConsumptionValidationError({
-      code: AgentConsumptionErrorCode.enum.AGENT_CONSUMPTION_DEPTH_EXCEEDED,
-      field: "depth",
-      message: `consumption depth exceeded: chain length ${chain.length} >= max depth ${guards.maxDepth}`
-    });
-  }
-}
-
-// src/shared/share-entry.ts
-import { z as z5 } from "zod";
-var nonEmptyString2 = z5.string().min(1);
-function isOpaqueLocatorId2(value) {
-  return value.trim() === value && !/[\0-\x1f\x7f]/.test(value) && !value.includes("/") && !value.includes("\\") && !value.includes(":") && value !== "." && value !== "..";
-}
-var OpaqueShareLocatorIdSchema = z5.string().min(1, "must be a non-empty opaque id").max(256, "must be at most 256 characters").refine(isOpaqueLocatorId2, "must be an opaque platform-owned id (no path separators, no scheme, no traversal)");
-function mintShareEntryId() {
-  return safeRandomUUID();
-}
-var ShareEntryProvenanceSchema = z5.object({
-  producerPrincipalRef: nonEmptyString2,
-  createdAt: nonEmptyString2
-}).strict();
-var ShareEntryV1Schema = z5.object({
-  schemaVersion: z5.literal(1),
-  id: OpaqueShareLocatorIdSchema,
-  workspaceId: OpaqueShareLocatorIdSchema,
-  path: nonEmptyString2,
-  provenance: ShareEntryProvenanceSchema
-}).strict();
-var ShareEntryErrorCode = z5.enum(["AR1_SHARE_NOT_FOUND", "AR1_SHARE_TOMBSTONED"]);
-var ShareEntryValidationCode = z5.enum(["SHARE_ENTRY_INPUT_INVALID"]);
-var ShareEntryValidationError = class extends Error {
-  code = ErrorCode.enum.CONFIG_INVALID;
-  field;
-  constructor(issue) {
-    super(issue.message);
-    this.name = "ShareEntryValidationError";
-    this.field = issue.field;
-  }
-};
-function assertValidCreateInput(raw) {
-  const result = CreateShareEntryInputSchema.safeParse(raw);
-  if (result.success) return;
-  const issue = result.error.issues[0];
-  const field = formatPath(issue.path);
-  throw new ShareEntryValidationError({
-    code: ShareEntryValidationCode.enum.SHARE_ENTRY_INPUT_INVALID,
-    field,
-    message: field === "<root>" ? issue.message : `${field} ${issue.message}`
-  });
-}
-var CreateShareEntryInputSchema = z5.object({
-  workspaceId: OpaqueShareLocatorIdSchema,
-  path: nonEmptyString2,
-  provenance: z5.object({
-    producerPrincipalRef: nonEmptyString2,
-    createdAt: nonEmptyString2.optional()
-  }).strict()
-}).strict();
-var InMemoryShareEntryStore = class {
-  entries = /* @__PURE__ */ new Map();
-  async create(input) {
-    assertValidCreateInput(input);
-    const entry = {
-      schemaVersion: 1,
-      id: mintShareEntryId(),
-      workspaceId: input.workspaceId,
-      path: input.path,
-      provenance: {
-        producerPrincipalRef: input.provenance.producerPrincipalRef,
-        createdAt: input.provenance.createdAt ?? (/* @__PURE__ */ new Date()).toISOString()
-      }
-    };
-    this.entries.set(entry.id, entry);
-    return entry;
-  }
-  async get(id) {
-    return this.entries.get(id) ?? null;
-  }
-  async delete(id) {
-    this.entries.delete(id);
-  }
-  async list(workspaceId) {
-    return Array.from(this.entries.values()).filter((entry) => entry.workspaceId === workspaceId);
-  }
-};
-async function resolveShareEntry(store, id, workspace) {
-  const entry = await store.get(id);
-  if (!entry) {
-    return { status: "not_found", code: ShareEntryErrorCode.enum.AR1_SHARE_NOT_FOUND };
-  }
-  try {
-    await workspace.stat(entry.path);
-  } catch {
-    return {
-      status: "tombstoned",
-      code: ShareEntryErrorCode.enum.AR1_SHARE_TOMBSTONED,
-      tombstone: {
-        id: entry.id,
-        workspaceId: entry.workspaceId,
-        provenance: entry.provenance
-      }
-    };
-  }
-  return { status: "ok", entry };
-}
-
-// src/shared/credentials/errors.ts
-var CREDENTIAL_ERROR_CODES = {
-  PROVIDER_UNKNOWN: "CREDENTIAL_PROVIDER_UNKNOWN",
-  NOT_CONFIGURED: "CREDENTIAL_NOT_CONFIGURED",
-  DISABLED: "CREDENTIAL_DISABLED",
-  REVOKED: "CREDENTIAL_REVOKED",
-  FORBIDDEN: "CREDENTIAL_FORBIDDEN",
-  WORKSPACE_MISMATCH: "CREDENTIAL_WORKSPACE_MISMATCH",
-  CONSUMER_MISMATCH: "CREDENTIAL_CONSUMER_MISMATCH",
-  DELIVERY_FORBIDDEN: "CREDENTIAL_DELIVERY_FORBIDDEN",
-  AUTHORITY_INVALID: "CREDENTIAL_AUTHORITY_INVALID",
-  SCHEMA_MISMATCH: "CREDENTIAL_SCHEMA_MISMATCH",
-  UNREADABLE: "CREDENTIAL_UNREADABLE",
-  BACKEND_UNAVAILABLE: "CREDENTIAL_BACKEND_UNAVAILABLE",
-  KEK_UNAVAILABLE: "CREDENTIAL_KEK_UNAVAILABLE",
-  LEASE_EXPIRED: "CREDENTIAL_LEASE_EXPIRED",
-  OAUTH_STATE_INVALID: "CREDENTIAL_OAUTH_STATE_INVALID",
-  OAUTH_REFRESH_FAILED: "CREDENTIAL_OAUTH_REFRESH_FAILED",
-  VALIDATION_UNAUTHORIZED: "CREDENTIAL_VALIDATION_UNAUTHORIZED",
-  VALIDATION_RATE_LIMITED: "CREDENTIAL_VALIDATION_RATE_LIMITED",
-  VALIDATION_UNAVAILABLE: "CREDENTIAL_VALIDATION_UNAVAILABLE",
-  VALIDATION_TIMEOUT: "CREDENTIAL_VALIDATION_TIMEOUT",
-  VALIDATION_UNSUPPORTED: "CREDENTIAL_VALIDATION_UNSUPPORTED"
-};
-var CredentialResolutionError = class extends Error {
-  code;
-  retryable;
-  constructor(code, message, options = {}) {
-    super(message);
-    this.name = "CredentialResolutionError";
-    this.code = code;
-    this.retryable = options.retryable ?? false;
-  }
-};
-
-// src/shared/credentials/custody.ts
-function workspaceCredentialCustodyScopeV1(workspaceId) {
-  return assertCredentialCustodyScopeV1({ workspaceId, subject: { kind: "workspace" } });
-}
-function userCredentialCustodyScopeV1(workspaceId, userId) {
-  return assertCredentialCustodyScopeV1({ workspaceId, subject: { kind: "user", userId } });
-}
-function assertCredentialCustodyScopeV1(scope) {
-  if (!scope || typeof scope.workspaceId !== "string" || scope.workspaceId.length === 0 || !scope.subject || scope.subject.kind !== "workspace" && scope.subject.kind !== "user" || scope.subject.kind === "user" && (typeof scope.subject.userId !== "string" || scope.subject.userId.length === 0)) {
-    throw new CredentialResolutionError(CREDENTIAL_ERROR_CODES.SCHEMA_MISMATCH, "Invalid credential custody scope");
-  }
-  return Object.freeze({
-    workspaceId: scope.workspaceId,
-    subject: scope.subject.kind === "workspace" ? Object.freeze({ kind: "workspace" }) : Object.freeze({ kind: "user", userId: scope.subject.userId })
-  });
-}
-function credentialCustodySubjectKeyV1(subject) {
-  return subject.kind === "workspace" ? "workspace" : encodeURIComponent(subject.userId);
-}
-
-// src/shared/credentials/bindings.ts
-var CREDENTIAL_ID_PATTERN = /^[a-z0-9][a-z0-9._-]{0,63}$/;
-var MAX_BINDING_TEXT_LENGTH_V1 = 256;
-function deepFreeze(value) {
-  if (value !== null && typeof value === "object" && !Object.isFrozen(value)) {
-    for (const child of Object.values(value)) {
-      deepFreeze(child);
-    }
-    Object.freeze(value);
-  }
-  return value;
-}
-function schemaMismatch(message) {
-  throw new CredentialResolutionError(
-    CREDENTIAL_ERROR_CODES.SCHEMA_MISMATCH,
-    message
-  );
-}
-function validateCredentialId(value, kind) {
-  if (typeof value !== "string" || !CREDENTIAL_ID_PATTERN.test(value)) {
-    schemaMismatch(`Invalid ${kind}`);
-  }
-}
-function validateBindingText(value, kind) {
-  if (typeof value !== "string" || value.length === 0 || value.length > MAX_BINDING_TEXT_LENGTH_V1 || /[\u0000-\u001f\u007f]/.test(value)) {
-    schemaMismatch(`Invalid ${kind}`);
-  }
-}
-function validateHttpsOrigin(value) {
-  if (typeof value !== "string") schemaMismatch("Invalid sandbox egress origin");
-  try {
-    const parsed = new URL(value);
-    if (parsed.protocol !== "https:" || parsed.username !== "" || parsed.password !== "" || parsed.origin !== value) {
-      schemaMismatch("Invalid sandbox egress origin");
-    }
-  } catch (error) {
-    if (error instanceof CredentialResolutionError) throw error;
-    schemaMismatch("Invalid sandbox egress origin");
-  }
-}
-function providerCredentialFieldsV1(provider) {
-  if (provider.credential.type === "api-key") return provider.credential.fields;
-  if (provider.credential.type === "oauth2-authorization-code" && provider.credential.tokenCustody === "local-vault") {
-    return [
-      provider.credential.refreshTokenField,
-      provider.credential.resolvedAccessTokenField
-    ];
-  }
-  return [];
-}
-function validateBinding(binding, providerRegistry) {
-  if (!binding || typeof binding !== "object") {
-    schemaMismatch("Invalid consumer binding");
-  }
-  if (binding.contractVersion !== "boring.credential-consumer-binding.v1") {
-    schemaMismatch("Invalid consumer binding contract version");
-  }
-  validateCredentialId(binding.id, "consumer binding id");
-  validateCredentialId(binding.providerId, "provider id");
-  if (!binding.consumer || typeof binding.consumer !== "object") {
-    schemaMismatch("Missing consumer binding identity");
-  }
-  validateBindingText(binding.consumer.id, "consumer id");
-  if (!["model-provider", "first-party-tool", "plugin-server", "mcp-server", "tenant-custom-tool"].includes(binding.consumer.kind)) {
-    schemaMismatch("Invalid consumer kind");
-  }
-  if (binding.consumer.trust !== "trusted" && binding.consumer.trust !== "untrusted") {
-    schemaMismatch("Invalid consumer trust");
-  }
-  validateBindingText(binding.purpose, "consumer purpose");
-  if (!Array.isArray(binding.allowedFieldIds)) schemaMismatch("Invalid allowed field ids");
-  if (!["host-only", "sandbox-pipe", "sandbox-tmpfs"].includes(binding.delivery)) {
-    schemaMismatch("Invalid credential delivery mode");
-  }
-  const provider = providerRegistry.list().find(
-    (candidate) => candidate.id === binding.providerId
-  );
-  if (!provider) schemaMismatch("Consumer binding references an unknown provider");
-  if (!provider.consumerBindingIds.includes(binding.id)) {
-    schemaMismatch("Provider does not declare consumer binding");
-  }
-  const availableFieldIds = new Set(
-    providerCredentialFieldsV1(provider).map((field) => field.id)
-  );
-  const allowedFieldIds = /* @__PURE__ */ new Set();
-  for (const fieldId of binding.allowedFieldIds) {
-    validateCredentialId(fieldId, "allowed credential field id");
-    if (allowedFieldIds.has(fieldId)) schemaMismatch("Duplicate allowed credential field id");
-    if (!availableFieldIds.has(fieldId)) schemaMismatch("Consumer binding requests an unknown field");
-    allowedFieldIds.add(fieldId);
-  }
-  if (provider.credential.type === "oauth2-authorization-code" && provider.credential.tokenCustody === "local-vault" && allowedFieldIds.has(provider.credential.refreshTokenField.id)) {
-    schemaMismatch("Consumer binding cannot request an OAuth refresh field");
-  }
-  if (binding.consumer.trust === "trusted") {
-    if (binding.delivery !== "host-only" || binding.sandbox !== void 0) {
-      schemaMismatch("Trusted consumers require host-only delivery");
-    }
-  } else {
-    if (binding.delivery === "host-only" || !binding.sandbox) {
-      schemaMismatch("Untrusted consumers require sandbox delivery");
-    }
-    if (binding.delivery === "sandbox-pipe" && binding.sandbox.credentialChannel !== "fd-3" || binding.delivery === "sandbox-tmpfs" && binding.sandbox.credentialChannel !== "tmpfs-v1") {
-      schemaMismatch("Sandbox delivery channel does not match delivery mode");
-    }
-    if (!Array.isArray(binding.sandbox.egressOrigins)) {
-      schemaMismatch("Missing sandbox egress origins");
-    }
-    const providerOrigins = new Set(provider.sandboxEgressOrigins);
-    const seenOrigins = /* @__PURE__ */ new Set();
-    for (const origin of binding.sandbox.egressOrigins) {
-      validateHttpsOrigin(origin);
-      if (seenOrigins.has(origin)) schemaMismatch("Duplicate sandbox egress origin");
-      if (!providerOrigins.has(origin)) schemaMismatch("Sandbox egress origin is not provider-approved");
-      seenOrigins.add(origin);
-    }
-  }
-  if (provider.credential.type === "oauth2-authorization-code" && provider.credential.tokenCustody === "external-managed" && (binding.allowedFieldIds.length !== 0 || binding.consumer.trust !== "trusted" || binding.delivery !== "host-only" || binding.sandbox !== void 0)) {
-    schemaMismatch("External-managed credentials require an empty host-only binding");
-  }
-}
-function createCredentialConsumerBindingRegistryV1(bindings, providerRegistry) {
-  const byId = /* @__PURE__ */ new Map();
-  for (const binding of bindings) {
-    validateBinding(binding, providerRegistry);
-    if (byId.has(binding.id)) schemaMismatch("Duplicate consumer binding id");
-    const immutableBinding = deepFreeze(binding);
-    byId.set(immutableBinding.id, immutableBinding);
-  }
-  return Object.freeze({
-    contractVersion: "boring.credential-consumer-bindings.v1",
-    require(bindingId) {
-      validateCredentialId(bindingId, "consumer binding id");
-      const binding = byId.get(bindingId);
-      if (!binding) {
-        throw new CredentialResolutionError(
-          CREDENTIAL_ERROR_CODES.CONSUMER_MISMATCH,
-          "Credential consumer binding is not registered"
-        );
-      }
-      return binding;
-    }
-  });
-}
-
-// src/shared/credentials/kmsBackend.ts
-var WORKSPACE_KEK_PROVIDER_VERSION = "boring.workspace-kek-provider.v1";
-var CREDENTIAL_ENVELOPE_VERSION = "boring.credential-envelope.v1";
-var CREDENTIAL_AAD_ENCODING_VERSION = "boring.credential-aad.v1";
-var CREDENTIAL_DEK_BYTE_LENGTH_V1 = 32;
-var CREDENTIAL_KEK_BYTE_LENGTH_V1 = 32;
-var CREDENTIAL_NONCE_BYTE_LENGTH_V1 = 12;
-var CREDENTIAL_AUTH_TAG_BYTE_LENGTH_V1 = 16;
-
-// src/shared/credentials/ref.ts
-var PROVIDER_CREDENTIAL_REF_VERSION = "boring.provider-credential-ref.v1";
-var MAX_EXECUTION_ID_LENGTH_V1 = 256;
-function createProviderCredentialRefFactoryV1(bindingRegistry) {
-  return Object.freeze({
-    contractVersion: "boring.provider-credential-ref-factory.v1",
-    create(input) {
-      const binding = bindingRegistry.require(input.bindingId);
-      if (binding.providerId !== input.providerId) {
-        throw new CredentialResolutionError(
-          CREDENTIAL_ERROR_CODES.CONSUMER_MISMATCH,
-          "Credential reference does not match its registered consumer binding"
-        );
-      }
-      if (typeof input.executionId !== "string" || input.executionId.trim().length === 0 || input.executionId.length > MAX_EXECUTION_ID_LENGTH_V1) {
-        throw new CredentialResolutionError(
-          CREDENTIAL_ERROR_CODES.SCHEMA_MISMATCH,
-          "Invalid credential execution id"
-        );
-      }
-      return Object.freeze({
-        contractVersion: PROVIDER_CREDENTIAL_REF_VERSION,
-        providerId: binding.providerId,
-        executionId: input.executionId,
-        bindingId: binding.id
-      });
-    }
-  });
-}
-
-// src/shared/credentials/registry.ts
-var CREDENTIAL_ID_PATTERN2 = /^[a-z0-9][a-z0-9._-]{0,63}$/;
-var MAX_CREDENTIAL_FIELD_BYTES_V1 = 65536;
-var MAX_ACCOUNT_REFERENCE_BYTES_V1 = 16384;
-var MAX_LABEL_LENGTH_V1 = 256;
-var MAX_SCOPE_LENGTH_V1 = 256;
-function deepFreeze2(value) {
-  if (value !== null && typeof value === "object" && !Object.isFrozen(value)) {
-    for (const child of Object.values(value)) {
-      deepFreeze2(child);
-    }
-    Object.freeze(value);
-  }
-  return value;
-}
-function schemaMismatch2(message) {
-  throw new CredentialResolutionError(
-    CREDENTIAL_ERROR_CODES.SCHEMA_MISMATCH,
-    message
-  );
-}
-function isCredentialId(value) {
-  return typeof value === "string" && CREDENTIAL_ID_PATTERN2.test(value);
-}
-function validateCredentialId2(value, kind) {
-  if (!isCredentialId(value)) schemaMismatch2(`Invalid ${kind}`);
-}
-function validateBoundedText(value, kind) {
-  if (typeof value !== "string" || value.length === 0 || value.length > MAX_LABEL_LENGTH_V1 || /[\u0000-\u001f\u007f]/.test(value)) {
-    schemaMismatch2(`Invalid ${kind}`);
-  }
-}
-function validateBoundedBytes(value, maximum, kind) {
-  if (!Number.isSafeInteger(value) || value <= 0 || value > maximum) {
-    schemaMismatch2(`Invalid ${kind}`);
-  }
-}
-function validateHttpsEndpoint(value, kind) {
-  if (typeof value !== "string") schemaMismatch2(`Invalid ${kind}`);
-  try {
-    const parsed = new URL(value);
-    if (parsed.protocol !== "https:" || parsed.username !== "" || parsed.password !== "" || parsed.hash !== "") {
-      schemaMismatch2(`Invalid ${kind}`);
-    }
-  } catch (error) {
-    if (error instanceof CredentialResolutionError) throw error;
-    schemaMismatch2(`Invalid ${kind}`);
-  }
-}
-function validateHttpsOrigin2(value, kind) {
-  validateHttpsEndpoint(value, kind);
-  const parsed = new URL(value);
-  if (parsed.origin !== value) schemaMismatch2(`Invalid ${kind}`);
-}
-function validateUniqueStrings(values, validate, kind) {
-  if (!Array.isArray(values)) schemaMismatch2(`Invalid ${kind}`);
-  const seen = /* @__PURE__ */ new Set();
-  for (const value of values) {
-    validate(value);
-    if (seen.has(value)) schemaMismatch2(`Duplicate ${kind}`);
-    seen.add(value);
-  }
-}
-function validateScopes(scopes) {
-  validateUniqueStrings(
-    scopes,
-    (scope) => {
-      if (typeof scope !== "string" || scope.length === 0 || scope.length > MAX_SCOPE_LENGTH_V1 || !/^[\x21-\x7e]+$/.test(scope)) {
-        schemaMismatch2("Invalid OAuth scope");
-      }
-    },
-    "OAuth scope"
-  );
-}
-function validateCredentialField(field) {
-  if (!field || typeof field !== "object") schemaMismatch2("Missing credential field");
-  validateCredentialId2(field.id, "credential field id");
-  validateBoundedText(field.label, "credential field label");
-  if (typeof field.required !== "boolean") schemaMismatch2("Invalid credential field required flag");
-  if (field.sensitivity !== "secret" && field.sensitivity !== "public") {
-    schemaMismatch2("Invalid credential field sensitivity");
-  }
-  validateBoundedBytes(field.maxBytes, MAX_CREDENTIAL_FIELD_BYTES_V1, "credential field maxBytes");
-  if (field.minBytes !== void 0 && (!Number.isSafeInteger(field.minBytes) || field.minBytes < 0 || field.minBytes > field.maxBytes)) {
-    schemaMismatch2("Invalid credential field minBytes");
-  }
-}
-function validateDistinctCredentialFields(fields) {
-  const seen = /* @__PURE__ */ new Set();
-  for (const field of fields) {
-    validateCredentialField(field);
-    if (seen.has(field.id)) schemaMismatch2("Duplicate credential field id");
-    seen.add(field.id);
-  }
-}
-function validateLocalVaultOAuth(credential) {
-  validateBoundedText(credential.clientRegistrationRef, "OAuth client registration reference");
-  validateHttpsEndpoint(credential.authorizationEndpoint, "OAuth authorization endpoint");
-  validateHttpsEndpoint(credential.tokenEndpoint, "OAuth token endpoint");
-  if (credential.revocationEndpoint !== void 0) {
-    validateHttpsEndpoint(credential.revocationEndpoint, "OAuth revocation endpoint");
-  }
-  validateScopes(credential.scopes);
-  if (credential.usePkce !== true || credential.accessTokenPersistence !== "memory-only") {
-    schemaMismatch2("Invalid local-vault OAuth policy");
-  }
-  validateCredentialField(credential.refreshTokenField);
-  validateCredentialField(credential.resolvedAccessTokenField);
-  if (credential.refreshTokenField.id === credential.resolvedAccessTokenField.id || credential.refreshTokenField.required !== true || credential.resolvedAccessTokenField.required !== true || credential.refreshTokenField.sensitivity !== "secret" || credential.resolvedAccessTokenField.sensitivity !== "secret") {
-    schemaMismatch2("Invalid local-vault OAuth token fields");
-  }
-}
-function validateExternalManagedOAuth(credential) {
-  const allowedProperties = /* @__PURE__ */ new Set([
-    "type",
-    "tokenCustody",
-    "custodianAdapterId",
-    "connectUrlOrigins",
-    "scopes",
-    "accountReference",
-    "delivery"
-  ]);
-  if (Object.keys(credential).some((key) => !allowedProperties.has(key))) {
-    schemaMismatch2("External-managed OAuth cannot declare token or secret fields");
-  }
-  validateBoundedText(credential.custodianAdapterId, "custodian adapter id");
-  validateUniqueStrings(
-    credential.connectUrlOrigins,
-    (origin) => validateHttpsOrigin2(origin, "connect URL origin"),
-    "connect URL origin"
-  );
-  validateScopes(credential.scopes);
-  if (!credential.accountReference || typeof credential.accountReference !== "object") {
-    schemaMismatch2("Missing external-managed account reference");
-  }
-  const allowedAccountReferenceProperties = /* @__PURE__ */ new Set([
-    "label",
-    "maxBytes",
-    "persistence"
-  ]);
-  if (Object.keys(credential.accountReference).some(
-    (key) => !allowedAccountReferenceProperties.has(key)
-  )) {
-    schemaMismatch2("External-managed account reference contains unsupported fields");
-  }
-  validateBoundedText(credential.accountReference.label, "account reference label");
-  validateBoundedBytes(
-    credential.accountReference.maxBytes,
-    MAX_ACCOUNT_REFERENCE_BYTES_V1,
-    "account reference maxBytes"
-  );
-  if (credential.accountReference.persistence !== "server-only-metadata" || credential.delivery !== "host-session-adapter-only") {
-    schemaMismatch2("Invalid external-managed OAuth custody policy");
-  }
-}
-function validateProviderDefinition(definition) {
-  if (!definition || typeof definition !== "object") {
-    schemaMismatch2("Invalid provider definition");
-  }
-  if (definition.contractVersion !== "boring.provider.v1") {
-    schemaMismatch2("Invalid provider contract version");
-  }
-  validateCredentialId2(definition.id, "provider id");
-  validateBoundedText(definition.displayName, "provider display name");
-  if (!["llm", "search", "transcription", "mcp", "other"].includes(definition.category)) {
-    schemaMismatch2("Invalid provider category");
-  }
-  validateUniqueStrings(
-    definition.consumerBindingIds,
-    (id) => validateCredentialId2(id, "consumer binding id"),
-    "consumer binding id"
-  );
-  validateUniqueStrings(
-    definition.sandboxEgressOrigins,
-    (origin) => validateHttpsOrigin2(origin, "sandbox egress origin"),
-    "sandbox egress origin"
-  );
-  if (!definition.credential || typeof definition.credential !== "object") {
-    schemaMismatch2("Missing provider credential definition");
-  }
-  const credential = definition.credential;
-  if (credential.type === "api-key") {
-    if (!Array.isArray(credential.fields) || credential.fields.length === 0) {
-      schemaMismatch2("API-key provider requires credential fields");
-    }
-    validateDistinctCredentialFields(credential.fields);
-  } else if (credential.type === "oauth2-authorization-code") {
-    if (credential.tokenCustody === "local-vault") {
-      validateLocalVaultOAuth(credential);
-    } else if (credential.tokenCustody === "external-managed") {
-      validateExternalManagedOAuth(credential);
-    } else {
-      schemaMismatch2("Invalid OAuth token custody");
-    }
-  } else if (credential.type !== "none") {
-    schemaMismatch2("Invalid provider credential type");
-  }
-  if (definition.mcp !== void 0) {
-    if (definition.mcp.transport !== "streamable-http") schemaMismatch2("Invalid MCP transport");
-    if (definition.mcp.endpoint !== void 0) {
-      validateHttpsEndpoint(definition.mcp.endpoint, "MCP endpoint");
-    }
-    if (definition.mcp.toolkitId !== void 0) {
-      validateBoundedText(definition.mcp.toolkitId, "MCP toolkit id");
-    }
-    validateUniqueStrings(
-      definition.mcp.allowedTools,
-      (tool) => validateBoundedText(tool, "MCP allowed tool"),
-      "MCP allowed tool"
-    );
-    validateUniqueStrings(
-      definition.mcp.deniedTools,
-      (tool) => validateBoundedText(tool, "MCP denied tool"),
-      "MCP denied tool"
-    );
-  }
-}
-function createProviderRegistryV1(defs) {
-  const providers = [];
-  const byId = /* @__PURE__ */ new Map();
-  for (const definition of defs) {
-    validateProviderDefinition(definition);
-    if (byId.has(definition.id)) schemaMismatch2("Duplicate provider id");
-    const immutableDefinition = deepFreeze2(definition);
-    providers.push(immutableDefinition);
-    byId.set(immutableDefinition.id, immutableDefinition);
-  }
-  const immutableProviders = Object.freeze(providers);
-  return Object.freeze({
-    contractVersion: "boring.provider-registry.v1",
-    list: () => immutableProviders,
-    require(providerId) {
-      validateCredentialId2(providerId, "provider id");
-      const provider = byId.get(providerId);
-      if (!provider) {
-        throw new CredentialResolutionError(
-          CREDENTIAL_ERROR_CODES.PROVIDER_UNKNOWN,
-          "Credential provider is not registered"
-        );
-      }
-      return provider;
-    }
-  });
-}
-
-// src/shared/credentials/sandboxDelivery.ts
-var SANDBOX_CREDENTIAL_MAX_FIELDS_V1 = 16;
-var SANDBOX_CREDENTIAL_MAX_METADATA_BYTES_V1 = 16384;
-var SANDBOX_CREDENTIAL_MAX_TOTAL_BYTES_V1 = 65536;
-function sandboxCredentialPayloadMetadataBytesV1(payload) {
-  return new TextEncoder().encode(JSON.stringify({
-    contractVersion: payload.contractVersion,
-    workspaceId: payload.workspaceId,
-    sandboxId: payload.sandboxId,
-    executionId: payload.executionId,
-    deliveryAttemptId: payload.deliveryAttemptId,
-    bindingId: payload.bindingId,
-    credentialVersion: payload.credentialVersion,
-    expiresAt: payload.expiresAt,
-    fields: payload.fields.map((field) => ({
-      fieldId: field.fieldId,
-      byteLength: field.value.byteLength
-    }))
-  })).byteLength;
-}
-function createNotImplementedSandboxCredentialPayloadResolverV1() {
-  return Object.freeze({
-    contractVersion: "boring.sandbox-credential-payload-resolver.v1",
-    async resolveForDelivery() {
-      throw new CredentialResolutionError(
-        CREDENTIAL_ERROR_CODES.DELIVERY_FORBIDDEN,
-        "Tier-2 in-sandbox injection not implemented in v1 (deferred to 16f.6)"
-      );
-    }
-  });
-}
-
-export {
-  AGENT_RESOURCES_FILESYSTEM_ID,
-  AGENT_KNOWLEDGE_FILESYSTEM_ID,
-  READONLY_FILESYSTEM_MUTATION_CODE,
-  RUNTIME_FILESYSTEM_CAPABILITIES,
-  ReadonlyFilesystemMutationError,
-  isReadonlyFilesystemMutationError,
-  CHANNEL_DESCRIPTORS,
-  channelDescriptor,
-  RuntimeModeSchema,
-  ConfigSchema,
-  EnvSchema,
-  validateConfig,
-  DEFAULT_AGENT_RUNTIME_CAPABILITIES,
-  PI_AGENT_RUNTIME_CAPABILITIES,
-  sha256,
-  sha256Bytes,
-  canonicalStringify,
-  OpaqueRefSchema,
-  Sha256DigestSchema,
-  validateAgentDefinition,
-  validateAgentDeployment,
-  createAgentAssetDigest,
-  AgentDefinitionValidationError,
-  AgentDeploymentValidationError,
-  createAgentDefinitionDigest,
-  createAgentDeploymentDigest,
-  validateTool,
-  TASK_STATES,
-  TaskStateSchema,
-  isValidTaskTransition,
-  assertValidTransition,
-  PrincipalRefSchema,
-  AgentRefSchema,
-  agentRefEquals,
-  ARTIFACT_LOCATOR_KINDS,
-  WorkspaceFileLocatorSchema,
-  ArtifactLocatorSchema,
-  ArtifactRefSchema,
-  PartSchema,
-  AgentMessageSchema,
-  AGENT_TASK_SCHEMA_VERSION,
-  AgentTaskSchema,
-  validateAgentTask,
-  AgentConsumptionValidationError,
-  parseAgentTaskEdgeCompat,
-  ConsumptionGuardsSchema,
-  validateConsumptionGuards,
-  detectConsumptionCycle,
-  assertNoConsumptionCycle,
-  isWithinConsumptionDepth,
-  assertWithinConsumptionDepth,
-  OpaqueShareLocatorIdSchema,
-  ShareEntryProvenanceSchema,
-  ShareEntryV1Schema,
-  ShareEntryErrorCode,
-  ShareEntryValidationError,
-  InMemoryShareEntryStore,
-  resolveShareEntry,
-  CREDENTIAL_ERROR_CODES,
-  CredentialResolutionError,
-  workspaceCredentialCustodyScopeV1,
-  userCredentialCustodyScopeV1,
-  assertCredentialCustodyScopeV1,
-  credentialCustodySubjectKeyV1,
-  providerCredentialFieldsV1,
-  createCredentialConsumerBindingRegistryV1,
-  WORKSPACE_KEK_PROVIDER_VERSION,
-  CREDENTIAL_ENVELOPE_VERSION,
-  CREDENTIAL_AAD_ENCODING_VERSION,
-  CREDENTIAL_DEK_BYTE_LENGTH_V1,
-  CREDENTIAL_KEK_BYTE_LENGTH_V1,
-  CREDENTIAL_NONCE_BYTE_LENGTH_V1,
-  CREDENTIAL_AUTH_TAG_BYTE_LENGTH_V1,
-  PROVIDER_CREDENTIAL_REF_VERSION,
-  createProviderCredentialRefFactoryV1,
-  createProviderRegistryV1,
-  SANDBOX_CREDENTIAL_MAX_FIELDS_V1,
-  SANDBOX_CREDENTIAL_MAX_METADATA_BYTES_V1,
-  SANDBOX_CREDENTIAL_MAX_TOTAL_BYTES_V1,
-  sandboxCredentialPayloadMetadataBytesV1,
-  createNotImplementedSandboxCredentialPayloadResolverV1
-};