pi-subagents 0.80.0 → 0.82.0

package/bundle/chunk-YKEWIB4M.js

@@ -0,0 +1,380 @@
+import {
+  BUILTIN_AGENT_NAMES,
+  CODE_OWNED_EXTERNAL_CLI_ADAPTER_LABEL,
+  applyRuntimeAgentSettings,
+  isCodeOwnedExternalCliAdapterId,
+  parseExternalCliCapabilityNarrowing,
+  validateAcceptanceInput,
+  validateCodeOwnedProfileRunner,
+  validatePermissionRules,
+  validateToolBudgetConfig
+} from "./chunk-CIZQXJ5Q.js";
+
+// src/agents/runtime-agent-registry.ts
+var RUNTIME_AGENT_REGISTRY_KEY = "pi-subagents.runtime-agents.v1";
+var MAX_RUNTIME_AGENTS_PER_PI = 200;
+var MAX_AGENT_NAME_LENGTH = 128;
+var MAX_DESCRIPTION_LENGTH = 4096;
+var MAX_SYSTEM_PROMPT_LENGTH = 1024 * 1024;
+var MAX_FIELD_STRING_LENGTH = 8192;
+function defaultSystemPromptMode(name) {
+  return name === "delegate" ? "append" : "replace";
+}
+function defaultInheritProjectContext(name) {
+  return name === "delegate";
+}
+function defaultInheritSkills() {
+  return false;
+}
+function registry() {
+  const key = Symbol.for(RUNTIME_AGENT_REGISTRY_KEY);
+  const globalObject = globalThis;
+  const existing = globalObject[key];
+  if (existing === void 0) {
+    const created = { version: 1, byPi: /* @__PURE__ */ new WeakMap() };
+    globalObject[key] = created;
+    return created;
+  }
+  if (!existing || typeof existing !== "object" || Array.isArray(existing)) {
+    throw new Error(`Malformed runtime agent registry at Symbol.for("${RUNTIME_AGENT_REGISTRY_KEY}").`);
+  }
+  const candidate = existing;
+  if (candidate.version !== 1 || !(candidate.byPi instanceof WeakMap)) {
+    throw new Error(`Unsupported runtime agent registry at Symbol.for("${RUNTIME_AGENT_REGISTRY_KEY}").`);
+  }
+  return candidate;
+}
+function validatePi(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("Runtime agent pi must be an ExtensionAPI object.");
+  const pi = value;
+  if (typeof pi.on !== "function" || typeof pi.registerTool !== "function") throw new Error("Runtime agent pi must be an ExtensionAPI object.");
+  return value;
+}
+function validateString(value, field, maxLength) {
+  if (typeof value !== "string" || value.length === 0 || value.trim() !== value) {
+    throw new Error(`${field} must be a non-empty string without leading or trailing whitespace.`);
+  }
+  if (value.length > maxLength) throw new Error(`${field} must be at most ${maxLength} characters.`);
+  if (value.includes("\0")) throw new Error(`${field} must not contain NUL characters.`);
+  return value;
+}
+function validateOptionalString(value, field, maxLength = MAX_FIELD_STRING_LENGTH) {
+  if (value === void 0) return void 0;
+  return validateString(value, field, maxLength);
+}
+function validateStringList(value, field) {
+  if (value === void 0) return void 0;
+  if (!Array.isArray(value)) throw new Error(`${field} must be an array of strings when provided.`);
+  return [...new Set(value.map((entry, index) => validateString(entry, `${field}[${index}]`, MAX_FIELD_STRING_LENGTH)))];
+}
+function validatePositiveInteger(value, field) {
+  if (value === void 0) return void 0;
+  if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) throw new Error(`${field} must be a positive integer when provided.`);
+  return value;
+}
+function validateBoolean(value, field) {
+  if (value === void 0) return void 0;
+  if (typeof value !== "boolean") throw new Error(`${field} must be a boolean when provided.`);
+  return value;
+}
+function isJsonSerializable(value) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") return true;
+  if (typeof value === "number") return Number.isFinite(value);
+  if (Array.isArray(value)) return value.every(isJsonSerializable);
+  if (value && typeof value === "object") return Object.values(value).every(isJsonSerializable);
+  return false;
+}
+function validateRunner(value) {
+  if (value === void 0) return void 0;
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("Runtime agent definition runner must be an object when provided.");
+  const runner = value;
+  if (runner.type === "pi") {
+    if (Object.keys(runner).some((key) => key !== "type")) throw new Error("Runtime agent definition Pi runner supports only 'type'.");
+    return { type: "pi" };
+  }
+  if (runner.type === "external-job") {
+    if (typeof runner.provider !== "string" || !runner.provider.trim() || runner.provider.trim() !== runner.provider) throw new Error("Runtime agent definition external-job runner requires a non-empty trimmed provider string.");
+    if (runner.options !== void 0 && (!runner.options || typeof runner.options !== "object" || Array.isArray(runner.options) || !isJsonSerializable(runner.options))) throw new Error("Runtime agent definition external-job runner options must be a JSON-serializable object.");
+    const supported2 = /* @__PURE__ */ new Set(["type", "provider", "options"]);
+    const unknown2 = Object.keys(runner).filter((key) => !supported2.has(key));
+    if (unknown2.length > 0) throw new Error(`Runtime agent definition external-job runner has unsupported fields: ${unknown2.join(", ")}.`);
+    return { type: "external-job", provider: runner.provider, ...runner.options ? { options: runner.options } : {} };
+  }
+  if (runner.type !== "external-cli") throw new Error("Runtime agent definition runner.type must be 'pi', 'external-cli', or 'external-job'.");
+  if (typeof runner.command !== "string" || !runner.command.trim()) throw new Error("Runtime agent definition external-cli runner requires a non-empty command string.");
+  if (runner.args !== void 0 && (!Array.isArray(runner.args) || runner.args.some((arg) => typeof arg !== "string"))) throw new Error("Runtime agent definition external-cli runner args must be an array of strings.");
+  if (runner.adapter !== void 0 && !isCodeOwnedExternalCliAdapterId(runner.adapter)) throw new Error(`Runtime agent definition external-cli runner adapter must be ${CODE_OWNED_EXTERNAL_CLI_ADAPTER_LABEL}.`);
+  if (runner.adapter !== void 0 && Array.isArray(runner.args) && runner.args.length > 0) throw new Error(`Runtime agent definition ${runner.adapter} adapter owns its argv; runner args are not supported.`);
+  if (runner.promptDelivery !== void 0 && runner.promptDelivery !== "stdin") throw new Error("Runtime agent definition external-cli runner promptDelivery must be 'stdin'.");
+  const capabilities = parseExternalCliCapabilityNarrowing(runner.capabilities, "Runtime agent definition external-cli runner capabilities");
+  const supported = /* @__PURE__ */ new Set(["type", "adapter", "command", "args", "promptDelivery", "capabilities"]);
+  const unknown = Object.keys(runner).filter((key) => !supported.has(key));
+  if (unknown.length > 0) throw new Error(`Runtime agent definition external-cli runner has unsupported fields: ${unknown.join(", ")}.`);
+  const args = runner.args;
+  return { type: "external-cli", ...isCodeOwnedExternalCliAdapterId(runner.adapter) ? { adapter: runner.adapter } : {}, command: runner.command.trim(), ...args?.length ? { args } : {}, ...runner.promptDelivery ? { promptDelivery: "stdin" } : {}, ...capabilities ? { capabilities } : {} };
+}
+function validateAcceptance(value) {
+  const errors = validateAcceptanceInput(value, "Runtime agent definition defaultAcceptance");
+  if (errors.length > 0) throw new Error(errors.join(" "));
+  return value;
+}
+function validateToolBudget(value) {
+  const result = validateToolBudgetConfig(value, "Runtime agent definition toolBudget");
+  if (result.error) throw new Error(result.error);
+  return result.budget;
+}
+function validateDefinition(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("Runtime agent definition must be an object.");
+  const definition = value;
+  const supported = /* @__PURE__ */ new Set([
+    "description",
+    "systemPrompt",
+    "aliases",
+    "tools",
+    "excludeTools",
+    "allowNestedSubagents",
+    "mcpDirectTools",
+    "model",
+    "thinking",
+    "systemPromptMode",
+    "inheritProjectContext",
+    "inheritGlobalContext",
+    "inheritSkills",
+    "defaultContext",
+    "defaultAsync",
+    "defaultTimeoutMs",
+    "defaultToolTimeoutMs",
+    "defaultAcceptance",
+    "acceptanceRole",
+    "runner",
+    "machine",
+    "skills",
+    "skillPath",
+    "extensions",
+    "subagentOnlyExtensions",
+    "mutationTools",
+    "output",
+    "outputMode",
+    "defaultReads",
+    "defaultProgress",
+    "interactive",
+    "maxSubagentDepth",
+    "toolBudget",
+    "permissions"
+  ]);
+  const unknown = Object.keys(definition).filter((key) => !supported.has(key));
+  if (unknown.length > 0) throw new Error(`Runtime agent definition has unknown fields: ${unknown.join(", ")}.`);
+  const systemPromptMode = definition.systemPromptMode;
+  if (systemPromptMode !== void 0 && systemPromptMode !== "append" && systemPromptMode !== "replace") throw new Error("Runtime agent definition systemPromptMode must be 'append' or 'replace'.");
+  const defaultContext = definition.defaultContext;
+  if (defaultContext !== void 0 && defaultContext !== "fresh" && defaultContext !== "fork") throw new Error("Runtime agent definition defaultContext must be 'fresh' or 'fork'.");
+  const thinking = definition.thinking;
+  if (thinking !== void 0 && thinking !== false && typeof thinking !== "string") throw new Error("Runtime agent definition thinking must be a string or false when provided.");
+  const acceptanceRole = definition.acceptanceRole;
+  if (acceptanceRole !== void 0 && acceptanceRole !== "read-only" && acceptanceRole !== "writer") throw new Error("Runtime agent definition acceptanceRole must be 'read-only' or 'writer'.");
+  const outputMode = definition.outputMode;
+  if (outputMode !== void 0 && outputMode !== "inline" && outputMode !== "file-only") throw new Error("Runtime agent definition outputMode must be 'inline' or 'file-only'.");
+  const aliases = validateStringList(definition.aliases, "Runtime agent definition aliases");
+  const tools = validateStringList(definition.tools, "Runtime agent definition tools");
+  const excludeTools = validateStringList(definition.excludeTools, "Runtime agent definition excludeTools");
+  const allowNestedSubagents = validateBoolean(definition.allowNestedSubagents, "Runtime agent definition allowNestedSubagents");
+  const mcpDirectTools = validateStringList(definition.mcpDirectTools, "Runtime agent definition mcpDirectTools");
+  const model = validateOptionalString(definition.model, "Runtime agent definition model");
+  if (definition.fallbackModels !== void 0) throw new Error("Runtime agent definition fallbackModels was removed; configure one model instead.");
+  const inheritProjectContext = validateBoolean(definition.inheritProjectContext, "Runtime agent definition inheritProjectContext");
+  const inheritGlobalContext = validateBoolean(definition.inheritGlobalContext, "Runtime agent definition inheritGlobalContext");
+  const inheritSkills = validateBoolean(definition.inheritSkills, "Runtime agent definition inheritSkills");
+  const defaultAsync = validateBoolean(definition.defaultAsync, "Runtime agent definition defaultAsync");
+  const defaultTimeoutMs = validatePositiveInteger(definition.defaultTimeoutMs, "Runtime agent definition defaultTimeoutMs");
+  const defaultToolTimeoutMs = validatePositiveInteger(definition.defaultToolTimeoutMs, "Runtime agent definition defaultToolTimeoutMs");
+  const defaultAcceptance = validateAcceptance(definition.defaultAcceptance);
+  const runner = validateRunner(definition.runner);
+  const skills = validateStringList(definition.skills, "Runtime agent definition skills");
+  const skillPath = validateStringList(definition.skillPath, "Runtime agent definition skillPath");
+  const extensions = validateStringList(definition.extensions, "Runtime agent definition extensions");
+  const subagentOnlyExtensions = validateStringList(definition.subagentOnlyExtensions, "Runtime agent definition subagentOnlyExtensions");
+  const mutationTools = validateStringList(definition.mutationTools, "Runtime agent definition mutationTools");
+  const machine = validateOptionalString(definition.machine, "Runtime agent definition machine");
+  const output = validateOptionalString(definition.output, "Runtime agent definition output");
+  const defaultReads = validateStringList(definition.defaultReads, "Runtime agent definition defaultReads");
+  const defaultProgress = validateBoolean(definition.defaultProgress, "Runtime agent definition defaultProgress");
+  const interactive = validateBoolean(definition.interactive, "Runtime agent definition interactive");
+  const maxSubagentDepth = validatePositiveInteger(definition.maxSubagentDepth, "Runtime agent definition maxSubagentDepth");
+  const toolBudget = validateToolBudget(definition.toolBudget);
+  const permissions = validatePermissionRules(definition.permissions, "Runtime agent definition permissions");
+  return {
+    description: validateString(definition.description, "Runtime agent definition description", MAX_DESCRIPTION_LENGTH),
+    systemPrompt: validateString(definition.systemPrompt, "Runtime agent definition systemPrompt", MAX_SYSTEM_PROMPT_LENGTH),
+    ...aliases ? { aliases } : {},
+    ...tools ? { tools } : {},
+    ...excludeTools ? { excludeTools } : {},
+    ...allowNestedSubagents !== void 0 ? { allowNestedSubagents } : {},
+    ...mcpDirectTools ? { mcpDirectTools } : {},
+    ...model ? { model } : {},
+    ...thinking !== void 0 ? { thinking } : {},
+    ...systemPromptMode !== void 0 ? { systemPromptMode } : {},
+    ...inheritProjectContext !== void 0 ? { inheritProjectContext } : {},
+    ...inheritGlobalContext !== void 0 ? { inheritGlobalContext } : {},
+    ...inheritSkills !== void 0 ? { inheritSkills } : {},
+    ...defaultContext !== void 0 ? { defaultContext } : {},
+    ...defaultAsync !== void 0 ? { defaultAsync } : {},
+    ...defaultTimeoutMs !== void 0 ? { defaultTimeoutMs } : {},
+    ...defaultToolTimeoutMs !== void 0 ? { defaultToolTimeoutMs } : {},
+    ...defaultAcceptance !== void 0 ? { defaultAcceptance } : {},
+    ...acceptanceRole !== void 0 ? { acceptanceRole } : {},
+    ...runner !== void 0 ? { runner } : {},
+    ...skills ? { skills } : {},
+    ...skillPath ? { skillPath } : {},
+    ...extensions ? { extensions } : {},
+    ...subagentOnlyExtensions ? { subagentOnlyExtensions } : {},
+    ...mutationTools ? { mutationTools } : {},
+    ...machine ? { machine } : {},
+    ...output ? { output } : {},
+    ...outputMode !== void 0 ? { outputMode } : {},
+    ...defaultReads ? { defaultReads } : {},
+    ...defaultProgress !== void 0 ? { defaultProgress } : {},
+    ...interactive !== void 0 ? { interactive } : {},
+    ...maxSubagentDepth !== void 0 ? { maxSubagentDepth } : {},
+    ...toolBudget !== void 0 ? { toolBudget } : {},
+    ...permissions !== void 0 ? { permissions } : {}
+  };
+}
+function normalizeAliases(rawAliases, agentName) {
+  const aliases = [...new Set((rawAliases ?? []).map((alias) => alias.trim()).filter(Boolean))].filter((alias) => alias !== agentName);
+  return aliases.length > 0 ? aliases : void 0;
+}
+function identityKeys(agent) {
+  return [agent.name, ...agent.localName ? [agent.localName] : [], ...agent.aliases ?? []];
+}
+function assertNoIdentityCollisions(agents, context) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const agent of agents) {
+    for (const key of identityKeys(agent)) {
+      const previous = seen.get(key);
+      if (previous !== void 0) throw new Error(`${context} collision for '${key}' between '${previous}' and '${agent.name}'.`);
+      seen.set(key, agent.name);
+    }
+  }
+}
+function assertNoRuntimeCollision(agent, existing) {
+  const existingKeys = /* @__PURE__ */ new Map();
+  for (const registered of existing) {
+    for (const key of identityKeys(registered)) existingKeys.set(key, registered.name);
+  }
+  for (const key of identityKeys(agent)) {
+    const previous = existingKeys.get(key);
+    if (previous !== void 0) throw new Error(`Runtime agent '${agent.name}' collides with runtime agent '${previous}' on name or alias '${key}'.`);
+  }
+}
+function assertNoBuiltinCollision(agent) {
+  for (const key of identityKeys(agent)) {
+    if (BUILTIN_AGENT_NAMES.includes(key)) throw new Error(`Runtime agent '${agent.name}' collides with builtin agent '${key}'.`);
+  }
+}
+function toAgentConfig(name, definition) {
+  const aliases = normalizeAliases(definition.aliases, name);
+  const agent = {
+    name,
+    description: definition.description,
+    ...aliases ? { aliases } : {},
+    ...definition.runner !== void 0 ? { runner: definition.runner } : {},
+    ...definition.tools !== void 0 ? { tools: [...definition.tools] } : {},
+    ...definition.excludeTools !== void 0 ? { excludeTools: [...definition.excludeTools] } : {},
+    ...definition.allowNestedSubagents !== void 0 ? { allowNestedSubagents: definition.allowNestedSubagents } : {},
+    ...definition.mcpDirectTools !== void 0 ? { mcpDirectTools: [...definition.mcpDirectTools] } : {},
+    ...definition.model !== void 0 ? { model: definition.model } : {},
+    ...definition.thinking !== void 0 ? { thinking: definition.thinking } : {},
+    systemPromptMode: definition.systemPromptMode ?? defaultSystemPromptMode(name),
+    inheritProjectContext: definition.inheritProjectContext ?? defaultInheritProjectContext(name),
+    inheritGlobalContext: definition.inheritGlobalContext ?? false,
+    inheritSkills: definition.inheritSkills ?? defaultInheritSkills(),
+    ...definition.defaultContext !== void 0 ? { defaultContext: definition.defaultContext } : {},
+    ...definition.defaultAsync !== void 0 ? { defaultAsync: definition.defaultAsync } : {},
+    ...definition.defaultTimeoutMs !== void 0 ? { defaultTimeoutMs: definition.defaultTimeoutMs } : {},
+    ...definition.defaultToolTimeoutMs !== void 0 ? { defaultToolTimeoutMs: definition.defaultToolTimeoutMs } : {},
+    ...definition.defaultAcceptance !== void 0 ? { defaultAcceptance: definition.defaultAcceptance } : {},
+    ...definition.acceptanceRole !== void 0 ? { acceptanceRole: definition.acceptanceRole } : {},
+    systemPrompt: definition.systemPrompt,
+    source: "runtime",
+    filePath: `runtime:${name}`,
+    ...definition.skills !== void 0 ? { skills: [...definition.skills] } : {},
+    ...definition.skillPath !== void 0 ? { skillPath: [...definition.skillPath] } : {},
+    ...definition.extensions !== void 0 ? { extensions: [...definition.extensions] } : {},
+    ...definition.subagentOnlyExtensions !== void 0 ? { subagentOnlyExtensions: [...definition.subagentOnlyExtensions] } : {},
+    ...definition.mutationTools !== void 0 ? { mutationTools: [...definition.mutationTools] } : {},
+    ...definition.machine !== void 0 ? { machine: definition.machine } : {},
+    ...definition.output !== void 0 ? { output: definition.output } : {},
+    ...definition.outputMode !== void 0 ? { outputMode: definition.outputMode } : {},
+    ...definition.defaultReads !== void 0 ? { defaultReads: [...definition.defaultReads] } : {},
+    ...definition.defaultProgress !== void 0 ? { defaultProgress: definition.defaultProgress } : {},
+    ...definition.interactive !== void 0 ? { interactive: definition.interactive } : {},
+    ...definition.maxSubagentDepth !== void 0 ? { maxSubagentDepth: definition.maxSubagentDepth } : {},
+    ...definition.toolBudget !== void 0 ? { toolBudget: definition.toolBudget } : {},
+    ...definition.permissions !== void 0 ? { permissions: definition.permissions } : {}
+  };
+  assertNoIdentityCollisions([agent], `Runtime agent '${name}'`);
+  return agent;
+}
+function registerRuntimeAgent(input) {
+  const pi = validatePi(input.pi);
+  const name = validateString(input.name, "Runtime agent name", MAX_AGENT_NAME_LENGTH);
+  const definition = validateDefinition(input.definition);
+  const agent = toAgentConfig(name, definition);
+  const profileError = validateCodeOwnedProfileRunner(agent);
+  if (profileError) throw new Error(profileError);
+  assertNoBuiltinCollision(agent);
+  const current = registry();
+  const records = current.byPi.get(pi) ?? [];
+  if (records.length >= MAX_RUNTIME_AGENTS_PER_PI) throw new Error(`Runtime agent registry supports at most ${MAX_RUNTIME_AGENTS_PER_PI} agents per Pi runtime.`);
+  assertNoRuntimeCollision(agent, records.map((record2) => record2.agent));
+  const record = { pi, agent };
+  records.push(record);
+  current.byPi.set(pi, records);
+  let disposed = false;
+  return {
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      const latest = current.byPi.get(pi);
+      if (!latest) return;
+      const next = latest.filter((entry) => entry !== record);
+      if (next.length > 0) current.byPi.set(pi, next);
+      else current.byPi.delete(pi);
+    }
+  };
+}
+function clearRuntimeAgentsForPi(pi) {
+  registry().byPi.delete(pi);
+}
+function listRuntimeAgentConfigs(pi) {
+  return (registry().byPi.get(pi) ?? []).map((record) => ({ ...record.agent, aliases: record.agent.aliases ? [...record.agent.aliases] : void 0 }));
+}
+function assertNoConfiguredCollision(configuredAgents, runtimeAgents) {
+  const configured = /* @__PURE__ */ new Map();
+  for (const agent of configuredAgents) {
+    for (const key of identityKeys(agent)) configured.set(key, agent.name);
+  }
+  for (const agent of runtimeAgents) {
+    for (const key of identityKeys(agent)) {
+      const previous = configured.get(key);
+      if (previous !== void 0) {
+        throw new Error(`Runtime agent '${agent.name}' collides with configured agent '${previous}' on name or alias '${key}'.`);
+      }
+    }
+  }
+}
+function mergeRuntimeAgents(pi, discovered, configuredAgents = discovered.agents, settings) {
+  const registered = listRuntimeAgentConfigs(pi).filter((agent) => agent.disabled !== true);
+  if (registered.length === 0) return discovered;
+  assertNoIdentityCollisions(registered, "Runtime agent registration");
+  assertNoConfiguredCollision(configuredAgents, registered);
+  const runtimeAgents = settings ? applyRuntimeAgentSettings(registered, settings) : registered;
+  return { ...discovered, agents: [...discovered.agents, ...runtimeAgents] };
+}
+
+export {
+  registerRuntimeAgent,
+  clearRuntimeAgentsForPi,
+  listRuntimeAgentConfigs,
+  mergeRuntimeAgents
+};

package/bundle/chunk-YYREO77V.js

@@ -0,0 +1,137 @@
+// src/api/external-job-provider.ts
+var EXTERNAL_JOB_PROVIDER_PROTOCOL_VERSION = 1;
+var EXTERNAL_JOB_PROVIDER_REGISTRY_KEY = "pi-subagents.external-job-providers.v1";
+var MAX_PROVIDER_NAME_LENGTH = 128;
+var MAX_PROVIDERS = 100;
+var MAX_JOB_ID_LENGTH = 256;
+var MAX_FAILURE_CODE_LENGTH = 128;
+var MAX_FAILURE_MESSAGE_LENGTH = 4096;
+var MAX_URL_LENGTH = 4096;
+var ExternalJobProviderError = class extends Error {
+  code;
+  blockingJobId;
+  constructor(message, options) {
+    super(message, options.cause === void 0 ? void 0 : { cause: options.cause });
+    this.name = "ExternalJobProviderError";
+    this.code = options.code;
+    this.blockingJobId = options.blockingJobId;
+  }
+};
+function registry() {
+  const key = Symbol.for(EXTERNAL_JOB_PROVIDER_REGISTRY_KEY);
+  const globalObject = globalThis;
+  const existing = globalObject[key];
+  if (existing === void 0) {
+    const created = {
+      version: EXTERNAL_JOB_PROVIDER_PROTOCOL_VERSION,
+      providers: /* @__PURE__ */ new Map()
+    };
+    globalObject[key] = created;
+    return created;
+  }
+  if (!existing || typeof existing !== "object" || Array.isArray(existing)) {
+    throw new Error(`Malformed external-job provider registry at Symbol.for("${EXTERNAL_JOB_PROVIDER_REGISTRY_KEY}").`);
+  }
+  const candidate = existing;
+  if (candidate.version !== EXTERNAL_JOB_PROVIDER_PROTOCOL_VERSION || !(candidate.providers instanceof Map)) {
+    throw new Error(`Unsupported external-job provider registry at Symbol.for("${EXTERNAL_JOB_PROVIDER_REGISTRY_KEY}").`);
+  }
+  return candidate;
+}
+function validateString(value, field, maxLength) {
+  if (typeof value !== "string" || value.length === 0 || value.trim() !== value) {
+    throw new Error(`${field} must be a non-empty string without leading or trailing whitespace.`);
+  }
+  if (value.length > maxLength) throw new Error(`${field} must be at most ${maxLength} characters.`);
+  if (value.includes("\0")) throw new Error(`${field} must not contain NUL characters.`);
+  return value;
+}
+function validateOptionalString(value, field, maxLength) {
+  if (value === void 0) return void 0;
+  return validateString(value, field, maxLength);
+}
+function validateState(value, field) {
+  if (value === "queued" || value === "running" || value === "completed" || value === "failed" || value === "stopped" || value === "blocked") return value;
+  throw new Error(`${field} must be queued, running, completed, failed, stopped, or blocked.`);
+}
+function validateHandle(provider, value, field, extraFields = []) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`${field} from external-job provider '${provider}' must be an object.`);
+  const handle = value;
+  const supported = /* @__PURE__ */ new Set(["providerJobId", "state", "handleUrl", "conversationUrl", "failureCode", "failureMessage", "blockingJobId", ...extraFields]);
+  const unknown = Object.keys(handle).filter((key) => !supported.has(key));
+  if (unknown.length > 0) throw new Error(`${field} from external-job provider '${provider}' has unknown fields: ${unknown.join(", ")}.`);
+  const handleUrl = validateOptionalString(handle.handleUrl, `${field}.handleUrl`, MAX_URL_LENGTH);
+  const conversationUrl = validateOptionalString(handle.conversationUrl, `${field}.conversationUrl`, MAX_URL_LENGTH);
+  const failureCode = validateOptionalString(handle.failureCode, `${field}.failureCode`, MAX_FAILURE_CODE_LENGTH);
+  const failureMessage = validateOptionalString(handle.failureMessage, `${field}.failureMessage`, MAX_FAILURE_MESSAGE_LENGTH);
+  const blockingJobId = validateOptionalString(handle.blockingJobId, `${field}.blockingJobId`, MAX_JOB_ID_LENGTH);
+  return {
+    providerJobId: validateString(handle.providerJobId, `${field}.providerJobId`, MAX_JOB_ID_LENGTH),
+    state: validateState(handle.state, `${field}.state`),
+    ...handleUrl ? { handleUrl } : {},
+    ...conversationUrl ? { conversationUrl } : {},
+    ...failureCode ? { failureCode } : {},
+    ...failureMessage ? { failureMessage } : {},
+    ...blockingJobId ? { blockingJobId } : {}
+  };
+}
+function validateExternalJobHandle(provider, value, field = "External-job handle") {
+  return validateHandle(provider, value, field);
+}
+function validateExternalJobResult(provider, value, field = "External-job result") {
+  const result = validateHandle(provider, value, field, ["output", "artifactPath"]);
+  const record = value;
+  const output = validateOptionalString(record.output, `${field}.output`, 1024 * 1024);
+  const artifactPath = validateOptionalString(record.artifactPath, `${field}.artifactPath`, MAX_URL_LENGTH);
+  return {
+    ...result,
+    ...output !== void 0 ? { output } : {},
+    ...artifactPath !== void 0 ? { artifactPath } : {}
+  };
+}
+function validateProvider(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("External-job provider must be an object.");
+  const provider = value;
+  const name = validateString(provider.name, "External-job provider name", MAX_PROVIDER_NAME_LENGTH);
+  for (const op of ["start", "status", "result", "reattach"]) {
+    if (typeof provider[op] !== "function") throw new Error(`External-job provider '${name}' must expose ${op}().`);
+  }
+  return value;
+}
+function registerExternalJobProvider(provider) {
+  const validated = validateProvider(provider);
+  const current = registry();
+  if (!current.providers.has(validated.name) && current.providers.size >= MAX_PROVIDERS) {
+    throw new Error(`External-job provider registry supports at most ${MAX_PROVIDERS} providers.`);
+  }
+  current.providers.set(validated.name, validated);
+  return () => {
+    if (current.providers.get(validated.name) === validated) current.providers.delete(validated.name);
+  };
+}
+function listExternalJobProviders() {
+  const current = registry();
+  if (current.providers.size > MAX_PROVIDERS) throw new Error(`External-job provider registry contains more than ${MAX_PROVIDERS} providers.`);
+  const providers = [];
+  for (const [key, value] of current.providers) {
+    const provider = validateProvider(value);
+    if (key !== provider.name) throw new Error(`External-job provider registry key '${key}' does not match provider name '${provider.name}'.`);
+    providers.push(provider);
+  }
+  return providers;
+}
+function getExternalJobProvider(name) {
+  const safeName = validateString(name, "External-job provider name", MAX_PROVIDER_NAME_LENGTH);
+  return listExternalJobProviders().find((provider) => provider.name === safeName);
+}
+
+export {
+  EXTERNAL_JOB_PROVIDER_PROTOCOL_VERSION,
+  EXTERNAL_JOB_PROVIDER_REGISTRY_KEY,
+  ExternalJobProviderError,
+  validateExternalJobHandle,
+  validateExternalJobResult,
+  registerExternalJobProvider,
+  listExternalJobProviders,
+  getExternalJobProvider
+};