@lore-co/core 0.1.17 → 0.1.19

package/dist/integration-contract.js

@@ -0,0 +1,679 @@
+import { z } from "zod";
+import { AgentReliabilityCapabilitiesSchema, RELIABILITY_CONTRACT_VERSION, } from "./reliability-schemas.js";
+export const RELIABILITY_INTEGRATION_CONTRACT_VERSION = "reliability-integration-v1";
+export const ReliabilityIntegrationIdSchema = z
+    .string()
+    .trim()
+    .min(1)
+    .max(100)
+    .regex(/^[a-z0-9](?:[a-z0-9._/-]*[a-z0-9])?$/u);
+export const ReliabilityCaptureOperationSchema = z.enum([
+    "observation",
+    "paired_turn",
+]);
+export const ReliabilityInstallationMechanismSchema = z.enum([
+    "command_hooks",
+    "plugin",
+    "server_connector",
+    "library",
+    "mcp_stdio",
+    "mcp_remote",
+]);
+const InvocationEventSchema = z
+    .string()
+    .trim()
+    .min(1)
+    .max(100)
+    .regex(/^[A-Za-z0-9][A-Za-z0-9._:/-]*$/u);
+export const ReliabilityIntegrationManifestSchema = z
+    .object({
+    integrationContractVersion: z.literal(RELIABILITY_INTEGRATION_CONTRACT_VERSION),
+    integrationId: ReliabilityIntegrationIdSchema,
+    displayName: z.string().trim().min(1).max(100),
+    capabilities: AgentReliabilityCapabilitiesSchema,
+    operations: z
+        .object({
+        capture: z.array(ReliabilityCaptureOperationSchema).max(2),
+        guard: z.boolean(),
+    })
+        .strict(),
+    installation: z
+        .object({
+        mechanism: ReliabilityInstallationMechanismSchema,
+        expectedUnits: z.number().int().positive().max(100).nullable(),
+    })
+        .strict(),
+    invocation: z
+        .object({
+        mode: z.enum(["event_driven", "polling", "host_managed"]),
+        events: z.array(InvocationEventSchema).max(20),
+    })
+        .strict(),
+})
+    .strict()
+    .superRefine((manifest, context) => {
+    if (new Set(manifest.operations.capture).size !==
+        manifest.operations.capture.length) {
+        context.addIssue({
+            code: "custom",
+            path: ["operations", "capture"],
+            message: "Capture operations must be unique",
+        });
+    }
+    if (new Set(manifest.invocation.events).size !==
+        manifest.invocation.events.length) {
+        context.addIssue({
+            code: "custom",
+            path: ["invocation", "events"],
+            message: "Invocation events must be unique",
+        });
+    }
+    if ((manifest.operations.capture.length === 0) !==
+        (manifest.capabilities.captureDurability === "none")) {
+        context.addIssue({
+            code: "custom",
+            path: ["operations", "capture"],
+            message: "Capture operations and capture durability must describe the same support",
+        });
+    }
+    if (manifest.operations.guard !==
+        (manifest.capabilities.guardBoundaryCoverage !== "none")) {
+        context.addIssue({
+            code: "custom",
+            path: ["operations", "guard"],
+            message: "Guard operation support requires an integration-owned host boundary",
+        });
+    }
+    const hookLike = manifest.installation.mechanism === "command_hooks" ||
+        manifest.installation.mechanism === "plugin";
+    if (hookLike !== (manifest.installation.expectedUnits !== null)) {
+        context.addIssue({
+            code: "custom",
+            path: ["installation", "expectedUnits"],
+            message: "Hook and plugin integrations must declare expected installation units",
+        });
+    }
+});
+export const ReliabilityInstallationUnitSchema = z
+    .object({
+    id: InvocationEventSchema,
+    state: z.enum(["exact", "missing", "drifted", "duplicate"]),
+})
+    .strict();
+export const ReliabilityInstallationHealthSchema = z
+    .object({
+    state: z.enum([
+        "complete",
+        "partial",
+        "missing",
+        "invalid",
+        "stale",
+        "not_applicable",
+    ]),
+    configured: z.boolean(),
+    executable: z.boolean().nullable(),
+    installedUnits: z.number().int().nonnegative(),
+    expectedUnits: z.number().int().nonnegative(),
+    units: z.array(ReliabilityInstallationUnitSchema).max(100),
+    runtime: z.enum(["not_required", "installed", "missing", "stale"]),
+    runtimeVersion: z.string().trim().min(1).max(100).nullable(),
+    expectedRuntimeVersion: z.string().trim().min(1).max(100).nullable(),
+    issue: z.literal("invalid_configuration").nullable(),
+})
+    .strict()
+    .superRefine((health, context) => {
+    const add = (path, message) => {
+        context.addIssue({ code: "custom", path, message });
+    };
+    if (health.state !== "invalid" &&
+        health.issue !== null) {
+        add(["issue"], "Only invalid installation state may include an issue");
+    }
+    if (health.state === "invalid" &&
+        health.issue !== "invalid_configuration") {
+        add(["issue"], "Invalid installation state requires its issue code");
+    }
+    if (health.state === "complete" &&
+        (health.installedUnits !== health.expectedUnits ||
+            health.units.length !== health.expectedUnits ||
+            health.units.some(({ state }) => state !== "exact") ||
+            (health.runtime !== "installed" &&
+                health.runtime !== "not_required"))) {
+        add(["state"], "Complete installation requires every unit and runtime to be exact");
+    }
+    if (health.state === "missing" &&
+        (health.installedUnits !== 0 ||
+            health.units.some(({ state }) => state !== "missing"))) {
+        add(["state"], "Missing installation cannot contain exact installation units");
+    }
+    if (health.state === "stale" && health.runtime !== "stale") {
+        add(["runtime"], "Stale installation requires a stale runtime");
+    }
+    if (health.state === "not_applicable" &&
+        (health.expectedUnits !== 0 ||
+            health.installedUnits !== 0 ||
+            health.units.length !== 0 ||
+            health.runtime !== "not_required")) {
+        add(["state"], "Not-applicable installation cannot declare units or a runtime");
+    }
+    if (health.runtime === "not_required" &&
+        (health.runtimeVersion !== null ||
+            health.expectedRuntimeVersion !== null)) {
+        add(["runtimeVersion"], "A runtime-free integration cannot declare runtime versions");
+    }
+});
+export const ReliabilityInvocationFailureCodeSchema = z.enum([
+    "invalid_input",
+    "runtime_error",
+]);
+const InvocationAttemptSchema = z
+    .object({
+    id: z.uuid(),
+    at: z.iso.datetime({ offset: true }),
+    runtimeVersion: z.string().trim().min(1).max(100).nullable(),
+})
+    .strict();
+const InvocationCompletionSchema = z.discriminatedUnion("outcome", [
+    z
+        .object({
+        attemptId: z.uuid(),
+        at: z.iso.datetime({ offset: true }),
+        outcome: z.literal("success"),
+        failureCode: z.null(),
+    })
+        .strict(),
+    z
+        .object({
+        attemptId: z.uuid(),
+        at: z.iso.datetime({ offset: true }),
+        outcome: z.literal("failure"),
+        failureCode: ReliabilityInvocationFailureCodeSchema,
+    })
+        .strict(),
+]);
+export const ReliabilityInvocationRecordSchema = z
+    .object({
+    version: z.literal(1),
+    integrationId: ReliabilityIntegrationIdSchema,
+    lastAttempt: InvocationAttemptSchema.nullable(),
+    lastCompletion: InvocationCompletionSchema.nullable(),
+})
+    .strict()
+    .superRefine((record, context) => {
+    if (record.lastAttempt === null && record.lastCompletion !== null) {
+        context.addIssue({
+            code: "custom",
+            path: ["lastCompletion"],
+            message: "A completion requires an invocation attempt",
+        });
+    }
+    if (record.lastAttempt !== null &&
+        record.lastCompletion !== null) {
+        const attemptedAt = Date.parse(record.lastAttempt.at);
+        const completedAt = Date.parse(record.lastCompletion.at);
+        const invalidChronology = record.lastCompletion.attemptId === record.lastAttempt.id
+            ? completedAt < attemptedAt
+            : completedAt > attemptedAt;
+        if (invalidChronology) {
+            context.addIssue({
+                code: "custom",
+                path: ["lastCompletion", "at"],
+                message: "Invocation completion chronology must match the latest attempt",
+            });
+        }
+    }
+});
+export const ReliabilityInvocationHealthSchema = z
+    .object({
+    state: z.enum([
+        "never_observed",
+        "successful",
+        "failed",
+        "incomplete",
+        "unknown",
+    ]),
+    lastAttemptedAt: z.iso.datetime({ offset: true }).nullable(),
+    lastSuccessfulAt: z.iso.datetime({ offset: true }).nullable(),
+    runtimeVersion: z.string().trim().min(1).max(100).nullable(),
+    failureCode: ReliabilityInvocationFailureCodeSchema.nullable(),
+})
+    .strict()
+    .superRefine((health, context) => {
+    const allNull = health.lastAttemptedAt === null &&
+        health.lastSuccessfulAt === null &&
+        health.runtimeVersion === null &&
+        health.failureCode === null;
+    if ((health.state === "never_observed" || health.state === "unknown") &&
+        !allNull) {
+        context.addIssue({
+            code: "custom",
+            path: ["state"],
+            message: `${health.state} invocation health cannot claim evidence`,
+        });
+    }
+    if (health.state === "successful" &&
+        (health.lastAttemptedAt === null ||
+            health.lastSuccessfulAt === null ||
+            health.failureCode !== null)) {
+        context.addIssue({
+            code: "custom",
+            path: ["state"],
+            message: "Successful invocation health requires success timestamps",
+        });
+    }
+    if (health.state === "failed" &&
+        (health.lastAttemptedAt === null ||
+            health.lastSuccessfulAt !== null ||
+            health.failureCode === null)) {
+        context.addIssue({
+            code: "custom",
+            path: ["state"],
+            message: "Failed invocation health requires a fixed failure code",
+        });
+    }
+    if (health.state === "incomplete" &&
+        (health.lastAttemptedAt === null || health.failureCode !== null)) {
+        context.addIssue({
+            code: "custom",
+            path: ["state"],
+            message: "Incomplete invocation health requires an unmatched attempt",
+        });
+    }
+});
+export const ReliabilityIntegrationHealthSchema = z
+    .object({
+    integrationContractVersion: z.literal(RELIABILITY_INTEGRATION_CONTRACT_VERSION),
+    integrationId: ReliabilityIntegrationIdSchema,
+    observedAt: z.iso.datetime({ offset: true }),
+    installation: ReliabilityInstallationHealthSchema,
+    invocation: ReliabilityInvocationHealthSchema,
+})
+    .strict();
+export function deriveReliabilityInvocationHealth(value, integrationId) {
+    const parsed = ReliabilityInvocationRecordSchema.safeParse(value);
+    if (!parsed.success || parsed.data.integrationId !== integrationId) {
+        return {
+            state: value === null ? "never_observed" : "unknown",
+            lastAttemptedAt: null,
+            lastSuccessfulAt: null,
+            runtimeVersion: null,
+            failureCode: null,
+        };
+    }
+    const { lastAttempt, lastCompletion } = parsed.data;
+    if (lastAttempt === null) {
+        return {
+            state: "never_observed",
+            lastAttemptedAt: null,
+            lastSuccessfulAt: null,
+            runtimeVersion: null,
+            failureCode: null,
+        };
+    }
+    if (lastCompletion === null ||
+        lastCompletion.attemptId !== lastAttempt.id) {
+        return {
+            state: "incomplete",
+            lastAttemptedAt: lastAttempt.at,
+            lastSuccessfulAt: lastCompletion?.outcome === "success" ? lastCompletion.at : null,
+            runtimeVersion: lastAttempt.runtimeVersion,
+            failureCode: null,
+        };
+    }
+    return {
+        state: lastCompletion.outcome === "success" ? "successful" : "failed",
+        lastAttemptedAt: lastAttempt.at,
+        lastSuccessfulAt: lastCompletion.outcome === "success" ? lastCompletion.at : null,
+        runtimeVersion: lastAttempt.runtimeVersion,
+        failureCode: lastCompletion.failureCode,
+    };
+}
+function deepFreeze(value) {
+    if (typeof value === "object" && value !== null && !Object.isFrozen(value)) {
+        for (const nested of Object.values(value)) {
+            deepFreeze(nested);
+        }
+        Object.freeze(value);
+    }
+    return value;
+}
+function manifest(value) {
+    return deepFreeze(ReliabilityIntegrationManifestSchema.parse(value));
+}
+export const CLAUDE_RELIABILITY_INTEGRATION = manifest({
+    integrationContractVersion: RELIABILITY_INTEGRATION_CONTRACT_VERSION,
+    integrationId: "native/claude",
+    displayName: "Claude Code native hooks",
+    capabilities: {
+        contractVersion: RELIABILITY_CONTRACT_VERSION,
+        agent: "claude",
+        contextDelivery: "pre_action",
+        captureDurability: "local_disk",
+        guardBoundaryCoverage: "partial",
+        guardedActions: ["edit", "command", "commit", "deploy"],
+        enforcement: "confirm",
+        stateDurability: "local_disk",
+        runtimeCoverage: ["local"],
+    },
+    operations: { capture: ["observation", "paired_turn"], guard: true },
+    installation: { mechanism: "command_hooks", expectedUnits: 4 },
+    invocation: {
+        mode: "event_driven",
+        events: ["UserPromptSubmit", "PreToolUse", "Stop", "SessionEnd"],
+    },
+});
+export const CODEX_RELIABILITY_INTEGRATION = manifest({
+    ...CLAUDE_RELIABILITY_INTEGRATION,
+    integrationId: "native/codex",
+    displayName: "Codex native hooks",
+    capabilities: {
+        ...CLAUDE_RELIABILITY_INTEGRATION.capabilities,
+        agent: "codex",
+    },
+});
+export const CURSOR_RELIABILITY_INTEGRATION = manifest({
+    integrationContractVersion: RELIABILITY_INTEGRATION_CONTRACT_VERSION,
+    integrationId: "native/cursor",
+    displayName: "Cursor native hooks",
+    capabilities: {
+        contractVersion: RELIABILITY_CONTRACT_VERSION,
+        agent: "cursor",
+        contextDelivery: "prompt",
+        captureDurability: "local_disk",
+        guardBoundaryCoverage: "partial",
+        guardedActions: ["command", "commit", "deploy"],
+        enforcement: "deny",
+        stateDurability: "local_disk",
+        runtimeCoverage: ["local"],
+    },
+    operations: { capture: ["observation", "paired_turn"], guard: true },
+    installation: { mechanism: "command_hooks", expectedUnits: 4 },
+    invocation: {
+        mode: "event_driven",
+        events: [
+            "beforeSubmitPrompt",
+            "beforeShellExecution",
+            "afterAgentResponse",
+            "sessionEnd",
+        ],
+    },
+});
+export const COPILOT_CLI_RELIABILITY_INTEGRATION = manifest({
+    integrationContractVersion: RELIABILITY_INTEGRATION_CONTRACT_VERSION,
+    integrationId: "native/copilot-cli",
+    displayName: "GitHub Copilot CLI native hooks",
+    capabilities: {
+        contractVersion: RELIABILITY_CONTRACT_VERSION,
+        agent: "copilot-cli",
+        contextDelivery: "prompt",
+        captureDurability: "local_disk",
+        guardBoundaryCoverage: "partial",
+        guardedActions: ["edit", "command", "commit", "deploy"],
+        enforcement: "confirm",
+        stateDurability: "local_disk",
+        runtimeCoverage: ["local"],
+    },
+    operations: { capture: ["observation", "paired_turn"], guard: true },
+    installation: { mechanism: "command_hooks", expectedUnits: 4 },
+    invocation: {
+        mode: "event_driven",
+        events: [
+            "userPromptTransformed",
+            "preToolUse",
+            "agentStop",
+            "sessionEnd",
+        ],
+    },
+});
+export const COPILOT_VSCODE_PREVIEW_RELIABILITY_INTEGRATION = manifest({
+    integrationContractVersion: RELIABILITY_INTEGRATION_CONTRACT_VERSION,
+    integrationId: "preview/copilot-vscode",
+    displayName: "GitHub Copilot in VS Code hooks (Preview)",
+    capabilities: {
+        contractVersion: RELIABILITY_CONTRACT_VERSION,
+        agent: "copilot-vscode",
+        contextDelivery: "prompt",
+        captureDurability: "local_disk",
+        guardBoundaryCoverage: "partial",
+        guardedActions: ["edit", "command", "commit", "deploy"],
+        enforcement: "confirm",
+        stateDurability: "local_disk",
+        runtimeCoverage: ["local"],
+    },
+    operations: { capture: ["observation", "paired_turn"], guard: true },
+    installation: { mechanism: "command_hooks", expectedUnits: 4 },
+    invocation: {
+        mode: "event_driven",
+        events: ["UserPromptSubmit", "PreToolUse", "Stop", "SessionEnd"],
+    },
+});
+export const COPILOT_CLOUD_MCP_RELIABILITY_INTEGRATION = manifest({
+    integrationContractVersion: RELIABILITY_INTEGRATION_CONTRACT_VERSION,
+    integrationId: "mcp/copilot-cloud",
+    displayName: "GitHub Copilot cloud Lore MCP",
+    capabilities: {
+        contractVersion: RELIABILITY_CONTRACT_VERSION,
+        agent: "copilot-cloud",
+        contextDelivery: "none",
+        captureDurability: "none",
+        guardBoundaryCoverage: "none",
+        guardedActions: [],
+        enforcement: "none",
+        stateDurability: "none",
+        runtimeCoverage: ["cloud"],
+    },
+    operations: { capture: [], guard: false },
+    installation: { mechanism: "mcp_remote", expectedUnits: null },
+    invocation: {
+        mode: "host_managed",
+        events: ["ask_lore", "search_learnings", "get_learning"],
+    },
+});
+export const POLYTOKEN_RELIABILITY_INTEGRATION = manifest({
+    integrationContractVersion: RELIABILITY_INTEGRATION_CONTRACT_VERSION,
+    integrationId: "native/polytoken",
+    displayName: "Polytoken native hooks",
+    capabilities: {
+        contractVersion: RELIABILITY_CONTRACT_VERSION,
+        agent: "polytoken",
+        contextDelivery: "prompt",
+        captureDurability: "local_disk",
+        guardBoundaryCoverage: "none",
+        guardedActions: [],
+        enforcement: "context_only",
+        stateDurability: "local_disk",
+        runtimeCoverage: ["local"],
+    },
+    operations: { capture: ["observation", "paired_turn"], guard: false },
+    installation: { mechanism: "command_hooks", expectedUnits: 2 },
+    invocation: {
+        mode: "event_driven",
+        events: ["pre_user_prompt", "post_model_turn"],
+    },
+});
+export const OPENCODE_RELIABILITY_INTEGRATION = manifest({
+    integrationContractVersion: RELIABILITY_INTEGRATION_CONTRACT_VERSION,
+    integrationId: "plugin/opencode",
+    displayName: "OpenCode plugin",
+    capabilities: {
+        contractVersion: RELIABILITY_CONTRACT_VERSION,
+        agent: "opencode",
+        contextDelivery: "prompt",
+        captureDurability: "local_disk",
+        guardBoundaryCoverage: "partial",
+        guardedActions: ["edit", "command", "commit", "deploy"],
+        enforcement: "deny",
+        stateDurability: "local_disk",
+        runtimeCoverage: ["local"],
+    },
+    operations: { capture: ["observation", "paired_turn"], guard: true },
+    installation: { mechanism: "plugin", expectedUnits: 1 },
+    invocation: {
+        mode: "event_driven",
+        events: [
+            "chat.message",
+            "experimental.chat.system.transform",
+            "tool.execute.before",
+            "session.idle",
+            "session.deleted",
+        ],
+    },
+});
+export const DEVIN_RELIABILITY_INTEGRATION = manifest({
+    integrationContractVersion: RELIABILITY_INTEGRATION_CONTRACT_VERSION,
+    integrationId: "connector/devin",
+    displayName: "Devin cloud connector",
+    capabilities: {
+        contractVersion: RELIABILITY_CONTRACT_VERSION,
+        agent: "devin",
+        contextDelivery: "prompt",
+        captureDurability: "server",
+        guardBoundaryCoverage: "none",
+        guardedActions: [],
+        enforcement: "context_only",
+        stateDurability: "server",
+        runtimeCoverage: ["cloud"],
+    },
+    operations: { capture: ["paired_turn"], guard: false },
+    installation: { mechanism: "server_connector", expectedUnits: null },
+    invocation: {
+        mode: "polling",
+        events: ["cli.start", "cli.prompt", "poller.messages"],
+    },
+});
+export const GENERIC_ADAPTER_RELIABILITY_INTEGRATION = manifest({
+    integrationContractVersion: RELIABILITY_INTEGRATION_CONTRACT_VERSION,
+    integrationId: "adapter/generic",
+    displayName: "Generic host adapter baseline",
+    capabilities: {
+        contractVersion: RELIABILITY_CONTRACT_VERSION,
+        agent: "generic-adapter",
+        contextDelivery: "prompt",
+        captureDurability: "server",
+        guardBoundaryCoverage: "none",
+        guardedActions: [],
+        enforcement: "none",
+        stateDurability: "none",
+        runtimeCoverage: ["local", "cloud"],
+    },
+    operations: { capture: ["observation", "paired_turn"], guard: false },
+    installation: { mechanism: "library", expectedUnits: null },
+    invocation: {
+        mode: "host_managed",
+        events: [
+            "observeEventReliable",
+            "processTurnReliable",
+            "guardCheckReliable",
+        ],
+    },
+});
+export const BEDROCK_RELIABILITY_INTEGRATION = manifest({
+    integrationContractVersion: RELIABILITY_INTEGRATION_CONTRACT_VERSION,
+    integrationId: "adapter/bedrock-agentcore",
+    displayName: "Amazon Bedrock AgentCore adapter",
+    capabilities: {
+        contractVersion: RELIABILITY_CONTRACT_VERSION,
+        agent: "bedrock-agentcore",
+        contextDelivery: "prompt",
+        captureDurability: "server",
+        guardBoundaryCoverage: "none",
+        guardedActions: [],
+        enforcement: "none",
+        stateDurability: "none",
+        runtimeCoverage: ["cloud"],
+    },
+    operations: { capture: ["observation", "paired_turn"], guard: false },
+    installation: { mechanism: "library", expectedUnits: null },
+    invocation: {
+        mode: "host_managed",
+        events: ["prepareInvocationReliable"],
+    },
+});
+export const MCP_RELIABILITY_INTEGRATION = manifest({
+    integrationContractVersion: RELIABILITY_INTEGRATION_CONTRACT_VERSION,
+    integrationId: "mcp/stdio",
+    displayName: "Lore MCP server",
+    capabilities: {
+        contractVersion: RELIABILITY_CONTRACT_VERSION,
+        agent: "mcp",
+        contextDelivery: "none",
+        captureDurability: "none",
+        guardBoundaryCoverage: "none",
+        guardedActions: [],
+        enforcement: "none",
+        stateDurability: "none",
+        runtimeCoverage: ["local"],
+    },
+    operations: { capture: [], guard: false },
+    installation: { mechanism: "mcp_stdio", expectedUnits: null },
+    invocation: {
+        mode: "event_driven",
+        events: [
+            "search_learnings",
+            "ask_lore",
+            "get_learning",
+            "remember_learning",
+            "correct_learning",
+            "forget_learning",
+        ],
+    },
+});
+export const CLAUDE_COWORK_MCP_RELIABILITY_INTEGRATION = manifest({
+    integrationContractVersion: RELIABILITY_INTEGRATION_CONTRACT_VERSION,
+    integrationId: "plugin/claude-cowork",
+    displayName: "Claude Cowork Lore plugin",
+    capabilities: {
+        contractVersion: RELIABILITY_CONTRACT_VERSION,
+        agent: "claude-cowork",
+        contextDelivery: "none",
+        captureDurability: "none",
+        guardBoundaryCoverage: "none",
+        guardedActions: [],
+        enforcement: "none",
+        stateDurability: "none",
+        runtimeCoverage: ["local"],
+    },
+    operations: { capture: [], guard: false },
+    installation: { mechanism: "plugin", expectedUnits: 1 },
+    invocation: {
+        mode: "host_managed",
+        events: ["ask_lore", "search_learnings", "get_learning"],
+    },
+});
+export function createReliabilityIntegrationRegistry(values) {
+    const entries = values
+        .map((value) => ReliabilityIntegrationManifestSchema.parse(value))
+        .sort((left, right) => left.integrationId < right.integrationId
+        ? -1
+        : left.integrationId > right.integrationId
+            ? 1
+            : 0);
+    const byId = new Map();
+    for (const entry of entries) {
+        if (byId.has(entry.integrationId)) {
+            throw new Error(`Duplicate reliability integration: ${entry.integrationId}`);
+        }
+        byId.set(entry.integrationId, deepFreeze(entry));
+    }
+    const listed = Object.freeze([...byId.values()]);
+    return Object.freeze({
+        get: (integrationId) => byId.get(integrationId),
+        list: () => listed,
+    });
+}
+export const OFFICIAL_RELIABILITY_INTEGRATIONS = createReliabilityIntegrationRegistry([
+    BEDROCK_RELIABILITY_INTEGRATION,
+    CLAUDE_COWORK_MCP_RELIABILITY_INTEGRATION,
+    CLAUDE_RELIABILITY_INTEGRATION,
+    CODEX_RELIABILITY_INTEGRATION,
+    COPILOT_CLI_RELIABILITY_INTEGRATION,
+    COPILOT_CLOUD_MCP_RELIABILITY_INTEGRATION,
+    COPILOT_VSCODE_PREVIEW_RELIABILITY_INTEGRATION,
+    CURSOR_RELIABILITY_INTEGRATION,
+    DEVIN_RELIABILITY_INTEGRATION,
+    GENERIC_ADAPTER_RELIABILITY_INTEGRATION,
+    MCP_RELIABILITY_INTEGRATION,
+    OPENCODE_RELIABILITY_INTEGRATION,
+    POLYTOKEN_RELIABILITY_INTEGRATION,
+]);
+//# sourceMappingURL=integration-contract.js.map