@agen-ai/agent-runtime 0.1.0

package/dist/outputValidation.js

@@ -0,0 +1,174 @@
+import {
+  parseAgentError
+} from "@agen-ai/agent-protocol";
+import { throwAgentProviderContractError } from "./contractErrors.js";
+import {
+  validateAgentProviderOutput
+} from "./outputs.js";
+function unsupportedCapabilitySemantic(value) {
+  throw new TypeError(
+    `Unsupported Agent Protocol capability semantic: ${String(value)}.`
+  );
+}
+function isItemKindCapabilitySupported(capabilities, itemKind) {
+  switch (itemKind) {
+    case "plan":
+      return capabilities.output.plans;
+    case "file_change":
+      return capabilities.output.fileChanges === "structured";
+    case "mcp_tool_call":
+      return capabilities.interactionExtensions.mcp;
+    case "collaboration_tool_call":
+      return capabilities.interactionExtensions.subagents;
+    case "user_message":
+    case "assistant_message":
+    case "reasoning":
+    case "command_execution":
+    case "dynamic_tool_call":
+    case "web_search":
+    case "browser_action":
+    case "computer_action":
+    case "image_view":
+    case "review":
+    case "context_compaction":
+    case "unknown":
+      return true;
+  }
+  return unsupportedCapabilitySemantic(itemKind);
+}
+function isContentStreamCapabilitySupported(capabilities, streamKind) {
+  switch (streamKind) {
+    case "plan_text":
+      return capabilities.output.plans;
+    case "file_change_output":
+      return capabilities.output.fileChanges === "structured";
+    case "assistant_text":
+    case "reasoning_text":
+    case "reasoning_summary":
+    case "command_output":
+    case "unknown":
+      return true;
+  }
+  return unsupportedCapabilitySemantic(streamKind);
+}
+function isEventCapabilitySupported(capabilities, event) {
+  switch (event.type) {
+    case "item.started":
+    case "item.updated":
+    case "item.completed":
+      return isItemKindCapabilitySupported(capabilities, event.payload.itemKind);
+    case "content.delta":
+      return capabilities.output.streaming && isContentStreamCapabilitySupported(
+        capabilities,
+        event.payload.streamKind
+      );
+    case "turn.plan.updated":
+    case "turn.plan.proposed":
+      return capabilities.output.plans;
+    case "turn.diff.updated":
+      return capabilities.output.fileChanges !== "none";
+    case "artifact.referenced":
+      return capabilities.output.artifactKinds.includes(
+        event.payload.artifact.kind
+      );
+    case "request.opened":
+      return event.payload.request.requestKind === "approval" ? capabilities.requests.approval : capabilities.requests.elicitation.kind === "structured" || capabilities.requests.elicitation.kind === "text" && event.payload.request.fields.every(
+        (field) => field.kind === "text"
+      );
+    case "turn.started":
+    case "turn.state_changed":
+    case "turn.completed":
+    case "progress.updated":
+    case "runtime.warning":
+    case "runtime.error":
+    case "provider.diagnostic":
+      return true;
+  }
+  return unsupportedCapabilitySemantic(event);
+}
+function assertOutputCapability(context, output) {
+  if (output.kind === "artifact") {
+    if (context.capabilities.output.artifactKinds.includes(
+      output.candidate.descriptor.kind
+    )) {
+      return;
+    }
+    throwAgentProviderContractError(
+      context.providerKey,
+      "output_capability_mismatch",
+      `Provider ${context.providerKey} emitted an artifact without advertising its kind.`
+    );
+  }
+  if (output.kind === "event" && !isEventCapabilitySupported(context.capabilities, output.event)) {
+    throwAgentProviderContractError(
+      context.providerKey,
+      "output_capability_mismatch",
+      `Provider ${context.providerKey} emitted ${output.event.type} without advertising support.`
+    );
+  }
+}
+function validateAgentProviderOutputForContext(candidate, context) {
+  const output = validateAgentProviderOutput(candidate);
+  if (output.kind === "event" && context.sessionId !== void 0) {
+    if (output.event.sessionId !== context.sessionId) {
+      throwAgentProviderContractError(
+        context.providerKey,
+        "output_session_mismatch",
+        `Provider ${context.providerKey} emitted an event for another session.`
+      );
+    }
+    if (context.turnId !== void 0 && output.event.turnId !== void 0 && output.event.turnId !== context.turnId) {
+      throwAgentProviderContractError(
+        context.providerKey,
+        "output_turn_mismatch",
+        `Provider ${context.providerKey} emitted an event for another turn.`
+      );
+    }
+  }
+  if (output.kind === "authentication" && output.progress.attemptId !== context.authenticationAttemptId) {
+    throwAgentProviderContractError(
+      context.providerKey,
+      "output_authentication_attempt_mismatch",
+      `Provider ${context.providerKey} emitted authentication progress for another attempt.`
+    );
+  }
+  assertOutputCapability(context, output);
+  return output;
+}
+function validateAgentProviderOperationResult(candidate, context) {
+  if (candidate === null || typeof candidate !== "object" || ![
+    "accepted",
+    "completed",
+    "failed",
+    "canceled",
+    "waiting_for_request"
+  ].includes(candidate.status) || candidate.outputs !== void 0 && !Array.isArray(candidate.outputs)) {
+    throwAgentProviderContractError(
+      context.providerKey,
+      "invalid_operation_result",
+      `Provider ${context.providerKey} returned an invalid operation result.`
+    );
+  }
+  if (candidate.status === "failed" !== (candidate.error !== void 0)) {
+    throwAgentProviderContractError(
+      context.providerKey,
+      "invalid_operation_result",
+      "Only failed provider operation results must include an error."
+    );
+  }
+  return Object.freeze({
+    status: candidate.status,
+    ...candidate.outputs === void 0 ? {} : {
+      outputs: Object.freeze(
+        candidate.outputs.map(
+          (output) => validateAgentProviderOutputForContext(output, context)
+        )
+      )
+    },
+    ...candidate.error === void 0 ? {} : { error: parseAgentError(candidate.error) }
+  });
+}
+export {
+  validateAgentProviderOperationResult,
+  validateAgentProviderOutputForContext
+};

package/dist/outputs.d.ts

@@ -0,0 +1,81 @@
+import { type AgentError, type AgentEvent, type AgentIsoDateTime } from "@agen-ai/agent-protocol";
+import { type AgentArtifactCandidate, type CreateAgentArtifactCandidateInput } from "./artifacts.js";
+import { type AgentProviderEvidence, type AgentProviderRequestContext, type CreateAgentProviderEvidenceInput } from "./evidence.js";
+export declare const AGENT_PROCESS_LIFECYCLE_TYPES: readonly ["process.started", "process.ready", "process.exited", "process.timeout", "process.interrupted", "process.error"];
+export type AgentProcessLifecycleType = (typeof AGENT_PROCESS_LIFECYCLE_TYPES)[number];
+export interface AgentProcessLifecycle {
+    readonly type: AgentProcessLifecycleType;
+    readonly occurredAt: AgentIsoDateTime;
+    readonly message?: string;
+    readonly exitCode?: number;
+    readonly error?: AgentError;
+}
+export declare const AGENT_AUTHENTICATION_STATUSES: readonly ["awaiting_user", "completed", "failed", "canceled", "expired"];
+export type AgentAuthenticationStatus = (typeof AGENT_AUTHENTICATION_STATUSES)[number];
+export interface AgentAuthenticationProgress {
+    readonly attemptId: string;
+    readonly status: AgentAuthenticationStatus;
+    readonly occurredAt: AgentIsoDateTime;
+    readonly providerLoginId?: string;
+    readonly verificationUrl?: string;
+    readonly userCode?: string;
+    readonly expiresAt?: AgentIsoDateTime;
+    readonly accountLabel?: string;
+    readonly error?: AgentError;
+}
+export interface AgentProviderEventOutput {
+    readonly kind: "event";
+    readonly event: AgentEvent;
+    readonly evidence?: AgentProviderObservationEvidence;
+    readonly requestContext?: AgentProviderRequestContext;
+}
+export interface AgentProviderLifecycleOutput {
+    readonly kind: "lifecycle";
+    readonly lifecycle: AgentProcessLifecycle;
+}
+export interface AgentProviderAuthenticationOutput {
+    readonly kind: "authentication";
+    readonly progress: AgentAuthenticationProgress;
+}
+export interface AgentProviderArtifactOutput {
+    readonly kind: "artifact";
+    readonly candidate: AgentArtifactCandidate;
+}
+export interface AgentProviderEvidenceOutput {
+    readonly kind: "evidence";
+    readonly evidence: AgentProviderDiagnosticEvidence;
+}
+export type AgentProviderObservationEvidence = AgentProviderEvidence & Readonly<{
+    category: "provider_event" | "provider_request";
+}>;
+export type AgentProviderDiagnosticEvidence = AgentProviderEvidence & Readonly<{
+    category: "diagnostic";
+}>;
+export type AgentProviderOutput = AgentProviderEventOutput | AgentProviderLifecycleOutput | AgentProviderAuthenticationOutput | AgentProviderArtifactOutput | AgentProviderEvidenceOutput;
+export interface CreateAgentEventOutputOptions {
+    readonly evidence?: AgentProviderObservationEvidence;
+    readonly requestContext?: AgentProviderRequestContext;
+}
+export declare function createAgentEventOutput(input: unknown, options?: CreateAgentEventOutputOptions): AgentProviderEventOutput;
+export declare function createAgentLifecycleOutput(input: {
+    readonly type: AgentProcessLifecycleType;
+    readonly occurredAt: string;
+    readonly message?: string;
+    readonly exitCode?: number;
+    readonly error?: AgentError;
+}): AgentProviderLifecycleOutput;
+export declare function createAgentAuthenticationOutput(input: {
+    readonly attemptId: string;
+    readonly status: AgentAuthenticationStatus;
+    readonly occurredAt: string;
+    readonly providerLoginId?: string;
+    readonly verificationUrl?: string;
+    readonly userCode?: string;
+    readonly expiresAt?: string;
+    readonly accountLabel?: string;
+    readonly error?: AgentError;
+}): AgentProviderAuthenticationOutput;
+export declare function createAgentArtifactOutput(input: CreateAgentArtifactCandidateInput): AgentProviderArtifactOutput;
+export declare function createAgentEvidenceOutput(input: CreateAgentProviderEvidenceInput<"diagnostic">): AgentProviderEvidenceOutput;
+export declare function validateAgentProviderOutput(input: unknown): AgentProviderOutput;
+//# sourceMappingURL=outputs.d.ts.map

package/dist/outputs.js

@@ -0,0 +1,217 @@
+import {
+  parseAgentError,
+  parseAgentEvent,
+  parseAgentIsoDateTime
+} from "@agen-ai/agent-protocol";
+import {
+  createAgentArtifactCandidate
+} from "./artifacts.js";
+import {
+  createAgentProviderEvidence,
+  validateAgentProviderRequestContext,
+  validateAgentProviderEvidence
+} from "./evidence.js";
+import {
+  parseAgentBoundedText,
+  parseAgentProviderTechnicalId
+} from "./foundation.js";
+import { containsAgentControlCharacter } from "./internal/controlCharacters.js";
+const AGENT_PROCESS_LIFECYCLE_TYPES = [
+  "process.started",
+  "process.ready",
+  "process.exited",
+  "process.timeout",
+  "process.interrupted",
+  "process.error"
+];
+const AGENT_AUTHENTICATION_STATUSES = [
+  "awaiting_user",
+  "completed",
+  "failed",
+  "canceled",
+  "expired"
+];
+const AGENT_AUTHENTICATION_VERIFICATION_URL_MAX_LENGTH = 2048;
+const AGENT_AUTHENTICATION_USER_CODE_MAX_LENGTH = 80;
+const AGENT_AUTHENTICATION_ACCOUNT_LABEL_MAX_LENGTH = 4e3;
+const AGENT_AUTHENTICATION_VERIFICATION_URL_PATTERN = /^[Hh][Tt][Tt][Pp][Ss]:\/\/(?![^/?#]*@)/u;
+function authenticationVerificationUrl(value) {
+  if (value.length > AGENT_AUTHENTICATION_VERIFICATION_URL_MAX_LENGTH || !AGENT_AUTHENTICATION_VERIFICATION_URL_PATTERN.test(value)) {
+    throw new TypeError(
+      "Authentication verificationUrl must use HTTPS without user information and contain at most 2,048 characters."
+    );
+  }
+  try {
+    new URL(value);
+  } catch {
+    throw new TypeError("Authentication verificationUrl must be a valid URL.");
+  }
+  return value;
+}
+function authenticationText(value, field, maxLength) {
+  const text = parseAgentBoundedText(value, field, maxLength);
+  if (text !== text.trim() || containsAgentControlCharacter(text)) {
+    throw new TypeError(
+      `${field} must be canonical text without surrounding whitespace or control characters.`
+    );
+  }
+  return text;
+}
+function boundedText(value, field) {
+  if (value === void 0) return void 0;
+  return parseAgentBoundedText(value, field, 4e3);
+}
+function validatedObservationEvidence(input) {
+  const evidence = validateAgentProviderEvidence(input);
+  if (evidence.category === "diagnostic") {
+    throw new TypeError(
+      "Agent event evidence must describe a provider event or request."
+    );
+  }
+  return evidence;
+}
+function validatedDiagnosticEvidence(input) {
+  const evidence = validateAgentProviderEvidence(input);
+  if (evidence.category !== "diagnostic") {
+    throw new TypeError(
+      "Standalone agent evidence must be diagnostic."
+    );
+  }
+  return evidence;
+}
+function createAgentEventOutput(input, options = {}) {
+  const event = parseAgentEvent(input);
+  if (options.requestContext !== void 0 && event.type !== "request.opened") {
+    throw new TypeError(
+      "Provider request context may be attached only to request.opened events."
+    );
+  }
+  if (options.evidence !== void 0 && options.evidence.category === "provider_request" !== (event.type === "request.opened")) {
+    throw new TypeError(
+      "Provider request evidence must be attached exactly to request.opened events."
+    );
+  }
+  return Object.freeze({
+    kind: "event",
+    event,
+    ...options.evidence === void 0 ? {} : { evidence: validatedObservationEvidence(options.evidence) },
+    ...options.requestContext === void 0 ? {} : {
+      requestContext: validateAgentProviderRequestContext(
+        options.requestContext
+      )
+    }
+  });
+}
+function createAgentLifecycleOutput(input) {
+  if (!AGENT_PROCESS_LIFECYCLE_TYPES.includes(input.type)) {
+    throw new TypeError("Agent process lifecycle type is unsupported.");
+  }
+  if (input.exitCode !== void 0 && (!Number.isSafeInteger(input.exitCode) || input.exitCode < -1)) {
+    throw new TypeError(
+      "Agent process exitCode must be a safe integer of at least -1."
+    );
+  }
+  return Object.freeze({
+    kind: "lifecycle",
+    lifecycle: Object.freeze({
+      type: input.type,
+      occurredAt: parseAgentIsoDateTime(input.occurredAt),
+      ...input.message === void 0 ? {} : { message: boundedText(input.message, "lifecycle message") },
+      ...input.exitCode === void 0 ? {} : { exitCode: input.exitCode },
+      ...input.error === void 0 ? {} : { error: parseAgentError(input.error) }
+    })
+  });
+}
+function createAgentAuthenticationOutput(input) {
+  if (!AGENT_AUTHENTICATION_STATUSES.includes(input.status)) {
+    throw new TypeError("Agent authentication status is unsupported.");
+  }
+  if (input.status === "failed" !== (input.error !== void 0)) {
+    throw new TypeError(
+      "Only failed agent authentication progress must include an error."
+    );
+  }
+  return Object.freeze({
+    kind: "authentication",
+    progress: Object.freeze({
+      attemptId: parseAgentProviderTechnicalId(input.attemptId, "attemptId"),
+      status: input.status,
+      occurredAt: parseAgentIsoDateTime(input.occurredAt),
+      ...input.providerLoginId === void 0 ? {} : {
+        providerLoginId: parseAgentProviderTechnicalId(
+          input.providerLoginId,
+          "providerLoginId"
+        )
+      },
+      ...input.verificationUrl === void 0 ? {} : {
+        verificationUrl: authenticationVerificationUrl(
+          input.verificationUrl
+        )
+      },
+      ...input.userCode === void 0 ? {} : {
+        userCode: authenticationText(
+          input.userCode,
+          "userCode",
+          AGENT_AUTHENTICATION_USER_CODE_MAX_LENGTH
+        )
+      },
+      ...input.expiresAt === void 0 ? {} : { expiresAt: parseAgentIsoDateTime(input.expiresAt) },
+      ...input.accountLabel === void 0 ? {} : {
+        accountLabel: authenticationText(
+          input.accountLabel,
+          "accountLabel",
+          AGENT_AUTHENTICATION_ACCOUNT_LABEL_MAX_LENGTH
+        )
+      },
+      ...input.error === void 0 ? {} : { error: parseAgentError(input.error) }
+    })
+  });
+}
+function createAgentArtifactOutput(input) {
+  return Object.freeze({
+    kind: "artifact",
+    candidate: createAgentArtifactCandidate(input)
+  });
+}
+function createAgentEvidenceOutput(input) {
+  return Object.freeze({
+    kind: "evidence",
+    evidence: validatedDiagnosticEvidence(createAgentProviderEvidence(input))
+  });
+}
+function validateAgentProviderOutput(input) {
+  if (input === null || typeof input !== "object" || !("kind" in input)) {
+    throw new TypeError("Agent provider output is invalid.");
+  }
+  const candidate = input;
+  switch (candidate.kind) {
+    case "event":
+      return createAgentEventOutput(candidate.event, {
+        ...candidate.evidence === void 0 ? {} : { evidence: candidate.evidence },
+        ...candidate.requestContext === void 0 ? {} : { requestContext: candidate.requestContext }
+      });
+    case "lifecycle":
+      return createAgentLifecycleOutput(candidate.lifecycle);
+    case "authentication":
+      return createAgentAuthenticationOutput(candidate.progress);
+    case "artifact":
+      return createAgentArtifactOutput(candidate.candidate);
+    case "evidence":
+      return Object.freeze({
+        kind: "evidence",
+        evidence: validatedDiagnosticEvidence(candidate.evidence)
+      });
+    default:
+      throw new TypeError("Agent provider output kind is unsupported.");
+  }
+}
+export {
+  AGENT_AUTHENTICATION_STATUSES,
+  AGENT_PROCESS_LIFECYCLE_TYPES,
+  createAgentArtifactOutput,
+  createAgentAuthenticationOutput,
+  createAgentEventOutput,
+  createAgentEvidenceOutput,
+  createAgentLifecycleOutput,
+  validateAgentProviderOutput
+};

package/dist/providerCatalog.d.ts

@@ -0,0 +1,13 @@
+import { type AgentCapabilities, type AgentInstanceId, type AgentProviderKey } from "@agen-ai/agent-protocol";
+import type { AgentProviderDriver, MaterializedAgentProviderInstance } from "./providerDriver.js";
+export interface AgentProviderCatalogEntry {
+    readonly providerKey: AgentProviderKey;
+    readonly supportsMultipleInstances: boolean;
+}
+export interface AgentProviderInstanceCatalogEntry {
+    readonly instanceId: AgentInstanceId;
+    readonly capabilities: AgentCapabilities;
+}
+export declare function createAgentProviderCatalogEntries(drivers: Iterable<AgentProviderDriver>): readonly AgentProviderCatalogEntry[];
+export declare function createAgentProviderInstanceCatalogEntries(instances: readonly MaterializedAgentProviderInstance[]): readonly AgentProviderInstanceCatalogEntry[];
+//# sourceMappingURL=providerCatalog.d.ts.map

package/dist/providerCatalog.js

@@ -0,0 +1,33 @@
+import {
+  parseAgentCapabilities
+} from "@agen-ai/agent-protocol";
+function compareStrings(left, right) {
+  if (left === right) return 0;
+  return left < right ? -1 : 1;
+}
+function createAgentProviderCatalogEntries(drivers) {
+  return Object.freeze(
+    [...drivers].map(
+      (driver) => Object.freeze({
+        providerKey: driver.providerKey,
+        supportsMultipleInstances: driver.supportsMultipleInstances
+      })
+    ).sort(
+      (left, right) => compareStrings(left.providerKey, right.providerKey)
+    )
+  );
+}
+function createAgentProviderInstanceCatalogEntries(instances) {
+  return Object.freeze(
+    instances.map(
+      (instance) => Object.freeze({
+        instanceId: instance.instanceId,
+        capabilities: parseAgentCapabilities(instance.capabilities)
+      })
+    ).sort((left, right) => compareStrings(left.instanceId, right.instanceId))
+  );
+}
+export {
+  createAgentProviderCatalogEntries,
+  createAgentProviderInstanceCatalogEntries
+};

package/dist/providerDriver.d.ts

@@ -0,0 +1,41 @@
+import { type AgentCapabilities, type AgentInstanceId, type AgentProviderKey } from "@agen-ai/agent-protocol";
+import type { MaybePromise } from "./foundation.js";
+import type { AgentProviderReadiness } from "./readiness.js";
+import type { AgentProviderAdapter } from "./sessions.js";
+export interface AgentProviderInstanceDefinition {
+    readonly providerKey: AgentProviderKey;
+    readonly instanceId: AgentInstanceId;
+    readonly driverConfiguration: unknown;
+}
+export interface AgentProviderReadinessCheckInput {
+    readonly signal?: AbortSignal;
+}
+export interface MaterializedAgentProviderInstance {
+    readonly instanceId: AgentInstanceId;
+    readonly capabilities: AgentCapabilities;
+    readonly adapter: AgentProviderAdapter;
+    readonly checkReadiness: (input?: AgentProviderReadinessCheckInput) => MaybePromise<AgentProviderReadiness>;
+    readonly dispose: () => MaybePromise<void>;
+}
+export interface AgentProviderDriverCreateInput<Configuration> {
+    readonly instanceId: AgentInstanceId;
+    readonly configuration: Configuration;
+}
+export interface AgentProviderDriverDefinition<Configuration> {
+    readonly providerKey: AgentProviderKey;
+    readonly supportsMultipleInstances: boolean;
+    readonly parseConfiguration: (input: unknown) => Configuration;
+    readonly validateConfiguration?: (input: AgentProviderDriverCreateInput<Configuration>) => void;
+    readonly createInstance: (input: AgentProviderDriverCreateInput<Configuration>) => MaybePromise<MaterializedAgentProviderInstance>;
+}
+export interface AgentProviderDriver {
+    readonly providerKey: AgentProviderKey;
+    readonly supportsMultipleInstances: boolean;
+    readonly materialize: (definition: AgentProviderInstanceDefinition) => MaybePromise<MaterializedAgentProviderInstance>;
+}
+export declare class AgentProviderConfigurationError extends Error {
+    readonly providerKey: AgentProviderKey;
+    constructor(providerKey: AgentProviderKey, options?: ErrorOptions);
+}
+export declare function defineAgentProviderDriver<Configuration>(definition: AgentProviderDriverDefinition<Configuration>): AgentProviderDriver;
+//# sourceMappingURL=providerDriver.d.ts.map

package/dist/providerDriver.js

@@ -0,0 +1,52 @@
+import {
+  parseAgentInstanceId,
+  parseAgentProviderKey
+} from "@agen-ai/agent-protocol";
+class AgentProviderConfigurationError extends Error {
+  constructor(providerKey, options) {
+    super(
+      `Agent provider configuration is invalid for ${providerKey}.`,
+      options
+    );
+    this.providerKey = providerKey;
+    this.name = "AgentProviderConfigurationError";
+  }
+  providerKey;
+}
+function defineAgentProviderDriver(definition) {
+  const providerKey = parseAgentProviderKey(definition.providerKey);
+  return Object.freeze({
+    providerKey,
+    supportsMultipleInstances: definition.supportsMultipleInstances,
+    materialize(instanceDefinition) {
+      let requestedProviderKey;
+      try {
+        requestedProviderKey = parseAgentProviderKey(
+          instanceDefinition.providerKey
+        );
+      } catch (cause) {
+        throw new AgentProviderConfigurationError(providerKey, { cause });
+      }
+      if (requestedProviderKey !== providerKey) {
+        throw new AgentProviderConfigurationError(providerKey);
+      }
+      let createInput;
+      try {
+        createInput = {
+          instanceId: parseAgentInstanceId(instanceDefinition.instanceId),
+          configuration: definition.parseConfiguration(
+            instanceDefinition.driverConfiguration
+          )
+        };
+        definition.validateConfiguration?.(createInput);
+      } catch (cause) {
+        throw new AgentProviderConfigurationError(providerKey, { cause });
+      }
+      return definition.createInstance(createInput);
+    }
+  });
+}
+export {
+  AgentProviderConfigurationError,
+  defineAgentProviderDriver
+};

package/dist/providerInstanceRegistry.d.ts

@@ -0,0 +1,40 @@
+import { type AgentInstanceId, type AgentProviderKey } from "@agen-ai/agent-protocol";
+import { type AgentProviderCatalogEntry, type AgentProviderInstanceCatalogEntry } from "./providerCatalog.js";
+import { type AgentProviderDriver, type AgentProviderInstanceDefinition, type MaterializedAgentProviderInstance } from "./providerDriver.js";
+import { type AgentProviderReadiness } from "./readiness.js";
+export declare const AGENT_PROVIDER_REGISTRY_ERROR_CODES: readonly ["invalid_driver", "duplicate_provider", "duplicate_instance", "provider_not_registered", "multiple_instances_unsupported", "invalid_instance_configuration", "instance_materialization_failed", "instance_contract_mismatch", "instance_not_found", "instance_disposed", "instance_cleanup_failed", "registry_disposed"];
+export type AgentProviderRegistryErrorCode = (typeof AGENT_PROVIDER_REGISTRY_ERROR_CODES)[number];
+interface AgentProviderRegistryErrorInput {
+    readonly code: AgentProviderRegistryErrorCode;
+    readonly message: string;
+    readonly providerKey?: AgentProviderKey;
+    readonly instanceId?: AgentInstanceId;
+    readonly cleanupFailureInstanceIds?: readonly AgentInstanceId[];
+    readonly cause?: unknown;
+}
+export declare class AgentProviderRegistryError extends Error {
+    readonly code: AgentProviderRegistryErrorCode;
+    readonly providerKey?: AgentProviderKey;
+    readonly instanceId?: AgentInstanceId;
+    readonly cleanupFailureInstanceIds: readonly AgentInstanceId[];
+    constructor(input: AgentProviderRegistryErrorInput);
+}
+export interface AgentProviderRegistry {
+    readonly listProviderCatalogEntries: () => readonly AgentProviderCatalogEntry[];
+    readonly listInstanceCatalogEntries: () => readonly AgentProviderInstanceCatalogEntry[];
+    readonly listInstances: () => readonly MaterializedAgentProviderInstance[];
+    readonly getInstance: (instanceId: AgentInstanceId) => MaterializedAgentProviderInstance | null;
+    readonly hasInstance: (instanceId: AgentInstanceId) => boolean;
+    readonly requireInstance: (instanceId: AgentInstanceId) => MaterializedAgentProviderInstance;
+    readonly checkReadiness: (instanceId: AgentInstanceId, input?: Readonly<{
+        signal?: AbortSignal;
+    }>) => Promise<AgentProviderReadiness>;
+    readonly dispose: () => Promise<void>;
+}
+export interface CreateAgentProviderRegistryInput {
+    readonly drivers: readonly AgentProviderDriver[];
+    readonly definitions: readonly AgentProviderInstanceDefinition[];
+}
+export declare function createAgentProviderRegistry(input: CreateAgentProviderRegistryInput): Promise<AgentProviderRegistry>;
+export {};
+//# sourceMappingURL=providerInstanceRegistry.d.ts.map