@opengeni/contracts 0.50.0 → 1.0.0

package/dist/agent-instruction-changes.d.ts

@@ -0,0 +1,110 @@
+import { z } from "zod";
+export declare const AgentInstructionEditMode: z.ZodEnum<{
+    append: "append";
+    edit: "edit";
+}>;
+export type AgentInstructionEditMode = z.infer<typeof AgentInstructionEditMode>;
+export declare const AgentInstructionSaveRequest: z.ZodObject<{
+    operationId: z.ZodUUID;
+    target: z.ZodObject<{
+        kind: z.ZodEnum<{
+            charter: "charter";
+            policy: "policy";
+        }>;
+        scope: z.ZodEnum<{
+            global: "global";
+            role: "role";
+        }>;
+        roleKey: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    editMode: z.ZodEnum<{
+        append: "append";
+        edit: "edit";
+    }>;
+    content: z.ZodOptional<z.ZodString>;
+    oldText: z.ZodOptional<z.ZodString>;
+    newText: z.ZodOptional<z.ZodString>;
+    expectedCurrentRevisionId: z.ZodNullable<z.ZodUUID>;
+    expectedActivationVersion: z.ZodNumber;
+    evidence: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        entryId: z.ZodUUID;
+        revisionId: z.ZodUUID;
+        location: z.ZodDefault<z.ZodObject<{
+            page: z.ZodOptional<z.ZodNumber>;
+            passage: z.ZodOptional<z.ZodString>;
+            messageIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            path: z.ZodOptional<z.ZodString>;
+            commit: z.ZodOptional<z.ZodString>;
+            lineStart: z.ZodOptional<z.ZodNumber>;
+            lineEnd: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+        quote: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    reason: z.ZodString;
+}, z.core.$strict>;
+export type AgentInstructionSaveRequest = z.input<typeof AgentInstructionSaveRequest>;
+export declare const AgentInstructionReviewRequest: z.ZodObject<{
+    operationId: z.ZodUUID;
+    revisionId: z.ZodUUID;
+    decision: z.ZodEnum<{
+        approve: "approve";
+        reject: "reject";
+    }>;
+    reason: z.ZodString;
+}, z.core.$strict>;
+export type AgentInstructionReviewRequest = z.infer<typeof AgentInstructionReviewRequest>;
+export declare const AgentInstructionReceipt: z.ZodObject<{
+    operationId: z.ZodUUID;
+    revisionId: z.ZodUUID;
+    outcome: z.ZodEnum<{
+        pending: "pending";
+        published: "published";
+        rejected: "rejected";
+    }>;
+    reviewBatchId: z.ZodNullable<z.ZodUUID>;
+    replayed: z.ZodBoolean;
+}, z.core.$strip>;
+export type AgentInstructionReceipt = z.infer<typeof AgentInstructionReceipt>;
+export declare const AgentInstructionReviewItem: z.ZodObject<{
+    revisionId: z.ZodUUID;
+    content: z.ZodString;
+    target: z.ZodObject<{
+        kind: z.ZodEnum<{
+            charter: "charter";
+            policy: "policy";
+        }>;
+        scope: z.ZodEnum<{
+            global: "global";
+            role: "role";
+        }>;
+        roleKey: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    reviewBatchId: z.ZodNullable<z.ZodUUID>;
+    sessionId: z.ZodNullable<z.ZodUUID>;
+    reason: z.ZodString;
+    createdAt: z.ZodString;
+}, z.core.$strip>;
+export type AgentInstructionReviewItem = z.infer<typeof AgentInstructionReviewItem>;
+export declare const AgentInstructionReviewListResponse: z.ZodObject<{
+    entries: z.ZodArray<z.ZodObject<{
+        revisionId: z.ZodUUID;
+        content: z.ZodString;
+        target: z.ZodObject<{
+            kind: z.ZodEnum<{
+                charter: "charter";
+                policy: "policy";
+            }>;
+            scope: z.ZodEnum<{
+                global: "global";
+                role: "role";
+            }>;
+            roleKey: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>;
+        reviewBatchId: z.ZodNullable<z.ZodUUID>;
+        sessionId: z.ZodNullable<z.ZodUUID>;
+        reason: z.ZodString;
+        createdAt: z.ZodString;
+    }, z.core.$strip>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type AgentInstructionReviewListResponse = z.infer<typeof AgentInstructionReviewListResponse>;

package/dist/agent-learning.d.ts

@@ -0,0 +1,243 @@
+import { z } from "zod";
+/** Review controls publication. It never grants content or external-action authority. */
+export declare const AgentLearningMode: z.ZodEnum<{
+    automatic: "automatic";
+    off: "off";
+    review_first: "review_first";
+}>;
+export type AgentLearningMode = z.infer<typeof AgentLearningMode>;
+export declare const AgentLearningCategory: z.ZodEnum<{
+    instructions: "instructions";
+    knowledge: "knowledge";
+    skills: "skills";
+}>;
+export type AgentLearningCategory = z.infer<typeof AgentLearningCategory>;
+export declare const AgentLearningDefaults: z.ZodObject<{
+    knowledge: z.ZodEnum<{
+        automatic: "automatic";
+        off: "off";
+        review_first: "review_first";
+    }>;
+    instructions: z.ZodEnum<{
+        automatic: "automatic";
+        off: "off";
+        review_first: "review_first";
+    }>;
+    skills: z.ZodEnum<{
+        automatic: "automatic";
+        off: "off";
+        review_first: "review_first";
+    }>;
+}, z.core.$strict>;
+export type AgentLearningDefaults = z.infer<typeof AgentLearningDefaults>;
+export declare const DEFAULT_AGENT_LEARNING: Readonly<AgentLearningDefaults>;
+/** An absent category inherits. `inherit` is a reset request, not persisted policy. */
+export declare const AgentLearningOverrides: z.ZodObject<{
+    knowledge: z.ZodOptional<z.ZodEnum<{
+        automatic: "automatic";
+        off: "off";
+        review_first: "review_first";
+    }>>;
+    instructions: z.ZodOptional<z.ZodEnum<{
+        automatic: "automatic";
+        off: "off";
+        review_first: "review_first";
+    }>>;
+    skills: z.ZodOptional<z.ZodEnum<{
+        automatic: "automatic";
+        off: "off";
+        review_first: "review_first";
+    }>>;
+}, z.core.$strict>;
+export type AgentLearningOverrides = z.infer<typeof AgentLearningOverrides>;
+export declare const AgentLearningOverridePatch: z.ZodObject<{
+    knowledge: z.ZodOptional<z.ZodUnion<[z.ZodEnum<{
+        automatic: "automatic";
+        off: "off";
+        review_first: "review_first";
+    }>, z.ZodLiteral<"inherit">]>>;
+    instructions: z.ZodOptional<z.ZodUnion<[z.ZodEnum<{
+        automatic: "automatic";
+        off: "off";
+        review_first: "review_first";
+    }>, z.ZodLiteral<"inherit">]>>;
+    skills: z.ZodOptional<z.ZodUnion<[z.ZodEnum<{
+        automatic: "automatic";
+        off: "off";
+        review_first: "review_first";
+    }>, z.ZodLiteral<"inherit">]>>;
+}, z.core.$strict>;
+export type AgentLearningOverridePatch = z.infer<typeof AgentLearningOverridePatch>;
+export declare const AgentLearningContext: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"chat">;
+    id: z.ZodUUID;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"scheduled_task">;
+    id: z.ZodUUID;
+}, z.core.$strict>], "kind">;
+export type AgentLearningContext = z.infer<typeof AgentLearningContext>;
+export declare const AgentLearningOwner: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"workspace">;
+    workspaceId: z.ZodUUID;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"personal">;
+    subjectId: z.ZodString;
+}, z.core.$strict>], "kind">;
+export type AgentLearningOwner = z.infer<typeof AgentLearningOwner>;
+export declare const AgentLearningSettings: z.ZodObject<{
+    owner: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"workspace">;
+        workspaceId: z.ZodUUID;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"personal">;
+        subjectId: z.ZodString;
+    }, z.core.$strict>], "kind">;
+    version: z.ZodNumber;
+    defaults: z.ZodObject<{
+        knowledge: z.ZodEnum<{
+            automatic: "automatic";
+            off: "off";
+            review_first: "review_first";
+        }>;
+        instructions: z.ZodEnum<{
+            automatic: "automatic";
+            off: "off";
+            review_first: "review_first";
+        }>;
+        skills: z.ZodEnum<{
+            automatic: "automatic";
+            off: "off";
+            review_first: "review_first";
+        }>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type AgentLearningSettings = z.infer<typeof AgentLearningSettings>;
+export declare const AgentLearningContextSettings: z.ZodObject<{
+    context: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"chat">;
+        id: z.ZodUUID;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"scheduled_task">;
+        id: z.ZodUUID;
+    }, z.core.$strict>], "kind">;
+    version: z.ZodNumber;
+    overrides: z.ZodObject<{
+        knowledge: z.ZodOptional<z.ZodEnum<{
+            automatic: "automatic";
+            off: "off";
+            review_first: "review_first";
+        }>>;
+        instructions: z.ZodOptional<z.ZodEnum<{
+            automatic: "automatic";
+            off: "off";
+            review_first: "review_first";
+        }>>;
+        skills: z.ZodOptional<z.ZodEnum<{
+            automatic: "automatic";
+            off: "off";
+            review_first: "review_first";
+        }>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type AgentLearningContextSettings = z.infer<typeof AgentLearningContextSettings>;
+/** Versioned settings returned by both central and contextual editors. */
+export declare const AgentLearningSettingsRecord: z.ZodObject<{
+    ownerKey: z.ZodString;
+    contextKey: z.ZodString;
+    version: z.ZodNumber;
+    settings: z.ZodObject<{
+        knowledge: z.ZodOptional<z.ZodEnum<{
+            automatic: "automatic";
+            off: "off";
+            review_first: "review_first";
+        }>>;
+        instructions: z.ZodOptional<z.ZodEnum<{
+            automatic: "automatic";
+            off: "off";
+            review_first: "review_first";
+        }>>;
+        skills: z.ZodOptional<z.ZodEnum<{
+            automatic: "automatic";
+            off: "off";
+            review_first: "review_first";
+        }>>;
+    }, z.core.$strict>;
+}, z.core.$strip>;
+export type AgentLearningSettingsRecord = z.infer<typeof AgentLearningSettingsRecord>;
+export declare const AgentLearningOverrideRecord: z.ZodObject<{
+    contextKey: z.ZodString;
+    version: z.ZodNumber;
+    settings: z.ZodObject<{
+        knowledge: z.ZodOptional<z.ZodEnum<{
+            automatic: "automatic";
+            off: "off";
+            review_first: "review_first";
+        }>>;
+        instructions: z.ZodOptional<z.ZodEnum<{
+            automatic: "automatic";
+            off: "off";
+            review_first: "review_first";
+        }>>;
+        skills: z.ZodOptional<z.ZodEnum<{
+            automatic: "automatic";
+            off: "off";
+            review_first: "review_first";
+        }>>;
+    }, z.core.$strict>;
+    updatedAt: z.ZodString;
+    label: z.ZodString;
+}, z.core.$strip>;
+export type AgentLearningOverrideRecord = z.infer<typeof AgentLearningOverrideRecord>;
+export type SaveAgentLearningSettingsRequest = {
+    scope: "workspace" | "personal";
+    source?: AgentLearningContext;
+    operationId: string;
+    expectedVersion: number;
+    settings: AgentLearningOverridePatch;
+};
+export declare const AgentLearningEffectiveCategory: z.ZodObject<{
+    mode: z.ZodEnum<{
+        automatic: "automatic";
+        off: "off";
+        review_first: "review_first";
+    }>;
+    inherited: z.ZodBoolean;
+}, z.core.$strict>;
+export declare const AgentLearningEffectivePolicy: z.ZodObject<{
+    knowledge: z.ZodObject<{
+        mode: z.ZodEnum<{
+            automatic: "automatic";
+            off: "off";
+            review_first: "review_first";
+        }>;
+        inherited: z.ZodBoolean;
+    }, z.core.$strict>;
+    instructions: z.ZodObject<{
+        mode: z.ZodEnum<{
+            automatic: "automatic";
+            off: "off";
+            review_first: "review_first";
+        }>;
+        inherited: z.ZodBoolean;
+    }, z.core.$strict>;
+    skills: z.ZodObject<{
+        mode: z.ZodEnum<{
+            automatic: "automatic";
+            off: "off";
+            review_first: "review_first";
+        }>;
+        inherited: z.ZodBoolean;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type AgentLearningEffectivePolicy = z.infer<typeof AgentLearningEffectivePolicy>;
+/** Apply only at an authorized settings boundary; this function confers no authority. */
+export declare function patchAgentLearningOverrides(current: AgentLearningOverrides, patch: AgentLearningOverridePatch): AgentLearningOverrides;
+/** Pure resolution over accepted settings. Runtime callers persist the resulting snapshot. */
+export declare function resolveAgentLearningPolicy(defaults: AgentLearningDefaults, overrides: AgentLearningOverrides): AgentLearningEffectivePolicy;
+/** Migration adapter preserves explicit opt-outs and existing instruction/Skill choices. */
+export declare function agentLearningDefaultsFromLegacy(input: {
+    memoryEnabled?: boolean;
+    workspaceMode?: "off" | "suggest" | "automatic";
+}): AgentLearningDefaults;
+/** Existing instruction and Skill lifecycles retain their native mode vocabulary. */
+export declare function agentLearningDestinationMode(mode: AgentLearningMode): "automatic" | "off" | "suggest";

package/dist/agent-topology.d.ts

@@ -0,0 +1,292 @@
+import { z } from "zod";
+/** Compact, bounded session projection for workspace agent-topology browsers. */
+export declare const AgentTopologySession: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodNullable<z.ZodString>;
+    titleTruncated: z.ZodBoolean;
+    parentSessionId: z.ZodNullable<z.ZodString>;
+    rootSessionId: z.ZodString;
+    nestedAgentDepth: z.ZodNumber;
+    ancestorPath: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodNullable<z.ZodString>;
+        titleTruncated: z.ZodBoolean;
+    }, z.core.$strip>>;
+    status: z.ZodEnum<{
+        cancelled: "cancelled";
+        failed: "failed";
+        idle: "idle";
+        queued: "queued";
+        recovering: "recovering";
+        requires_action: "requires_action";
+        running: "running";
+        waiting_capacity: "waiting_capacity";
+    }>;
+    goal: z.ZodNullable<z.ZodObject<{
+        status: z.ZodEnum<{
+            active: "active";
+            completed: "completed";
+            paused: "paused";
+        }>;
+        summary: z.ZodString;
+        summaryTruncated: z.ZodBoolean;
+    }, z.core.$strip>>;
+    pause: z.ZodObject<{
+        state: z.ZodEnum<{
+            active: "active";
+            paused: "paused";
+        }>;
+        additionalBlockerCount: z.ZodNumber;
+        source: z.ZodNullable<z.ZodObject<{
+            kind: z.ZodEnum<{
+                session: "session";
+                workspace: "workspace";
+            }>;
+            sessionId: z.ZodOptional<z.ZodString>;
+            displayName: z.ZodString;
+            displayNameTruncated: z.ZodBoolean;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    children: z.ZodObject<{
+        directChildren: z.ZodNumber;
+        totalDescendants: z.ZodNumber;
+        runningDescendants: z.ZodNumber;
+        queuedDescendants: z.ZodNumber;
+        attentionDescendants: z.ZodNumber;
+        pausedDescendants: z.ZodNumber;
+        failedDescendants: z.ZodNumber;
+        truncated: z.ZodBoolean;
+    }, z.core.$strip>;
+    relatedWork: z.ZodObject<{
+        claims: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            sessionId: z.ZodString;
+            subject: z.ZodObject<{
+                namespace: z.ZodString;
+                type: z.ZodEnum<{
+                    artifact: "artifact";
+                    branch: "branch";
+                    ci_run: "ci_run";
+                    issue: "issue";
+                    other: "other";
+                    pull_request: "pull_request";
+                    release: "release";
+                    repository: "repository";
+                }>;
+                canonicalKey: z.ZodString;
+                displayLabel: z.ZodNullable<z.ZodString>;
+            }, z.core.$strip>;
+            role: z.ZodEnum<{
+                delivering: "delivering";
+                monitoring: "monitoring";
+                reviewing: "reviewing";
+                working: "working";
+            }>;
+            state: z.ZodEnum<{
+                active: "active";
+                released: "released";
+                stale: "stale";
+                superseded: "superseded";
+            }>;
+            revision: z.ZodNumber;
+            provenance: z.ZodEnum<{
+                explicit_agent: "explicit_agent";
+                session_resource: "session_resource";
+                system_lifecycle: "system_lifecycle";
+                trusted_integration: "trusted_integration";
+                user_api: "user_api";
+            }>;
+            version: z.ZodNullable<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    artifact_version: "artifact_version";
+                    branch_head: "branch_head";
+                    ci_run: "ci_run";
+                    git_commit: "git_commit";
+                    other: "other";
+                    pull_request_head: "pull_request_head";
+                    release_version: "release_version";
+                }>;
+                value: z.ZodString;
+            }, z.core.$strip>>;
+            observedAt: z.ZodString;
+            updatedAt: z.ZodString;
+            settledAt: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+        claimsTruncated: z.ZodBoolean;
+        match: z.ZodNullable<z.ZodObject<{
+            class: z.ZodEnum<{
+                exact_subject: "exact_subject";
+                fuzzy: "fuzzy";
+                goal: "goal";
+                title: "title";
+            }>;
+            field: z.ZodEnum<{
+                claim_key: "claim_key";
+                claim_label: "claim_label";
+                goal: "goal";
+                subject: "subject";
+                title: "title";
+            }>;
+            scoreBand: z.ZodEnum<{
+                exact: "exact";
+                related: "related";
+                strong: "strong";
+            }>;
+            claimId: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>>;
+        possibleOverlap: z.ZodBoolean;
+        advisoryOnly: z.ZodLiteral<true>;
+        noAdditionalAccess: z.ZodLiteral<true>;
+    }, z.core.$strict>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strip>;
+export type AgentTopologySession = z.infer<typeof AgentTopologySession>;
+export declare const AgentTopologyPageResponse: z.ZodObject<{
+    sessions: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodNullable<z.ZodString>;
+        titleTruncated: z.ZodBoolean;
+        parentSessionId: z.ZodNullable<z.ZodString>;
+        rootSessionId: z.ZodString;
+        nestedAgentDepth: z.ZodNumber;
+        ancestorPath: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            title: z.ZodNullable<z.ZodString>;
+            titleTruncated: z.ZodBoolean;
+        }, z.core.$strip>>;
+        status: z.ZodEnum<{
+            cancelled: "cancelled";
+            failed: "failed";
+            idle: "idle";
+            queued: "queued";
+            recovering: "recovering";
+            requires_action: "requires_action";
+            running: "running";
+            waiting_capacity: "waiting_capacity";
+        }>;
+        goal: z.ZodNullable<z.ZodObject<{
+            status: z.ZodEnum<{
+                active: "active";
+                completed: "completed";
+                paused: "paused";
+            }>;
+            summary: z.ZodString;
+            summaryTruncated: z.ZodBoolean;
+        }, z.core.$strip>>;
+        pause: z.ZodObject<{
+            state: z.ZodEnum<{
+                active: "active";
+                paused: "paused";
+            }>;
+            additionalBlockerCount: z.ZodNumber;
+            source: z.ZodNullable<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    session: "session";
+                    workspace: "workspace";
+                }>;
+                sessionId: z.ZodOptional<z.ZodString>;
+                displayName: z.ZodString;
+                displayNameTruncated: z.ZodBoolean;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        children: z.ZodObject<{
+            directChildren: z.ZodNumber;
+            totalDescendants: z.ZodNumber;
+            runningDescendants: z.ZodNumber;
+            queuedDescendants: z.ZodNumber;
+            attentionDescendants: z.ZodNumber;
+            pausedDescendants: z.ZodNumber;
+            failedDescendants: z.ZodNumber;
+            truncated: z.ZodBoolean;
+        }, z.core.$strip>;
+        relatedWork: z.ZodObject<{
+            claims: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                sessionId: z.ZodString;
+                subject: z.ZodObject<{
+                    namespace: z.ZodString;
+                    type: z.ZodEnum<{
+                        artifact: "artifact";
+                        branch: "branch";
+                        ci_run: "ci_run";
+                        issue: "issue";
+                        other: "other";
+                        pull_request: "pull_request";
+                        release: "release";
+                        repository: "repository";
+                    }>;
+                    canonicalKey: z.ZodString;
+                    displayLabel: z.ZodNullable<z.ZodString>;
+                }, z.core.$strip>;
+                role: z.ZodEnum<{
+                    delivering: "delivering";
+                    monitoring: "monitoring";
+                    reviewing: "reviewing";
+                    working: "working";
+                }>;
+                state: z.ZodEnum<{
+                    active: "active";
+                    released: "released";
+                    stale: "stale";
+                    superseded: "superseded";
+                }>;
+                revision: z.ZodNumber;
+                provenance: z.ZodEnum<{
+                    explicit_agent: "explicit_agent";
+                    session_resource: "session_resource";
+                    system_lifecycle: "system_lifecycle";
+                    trusted_integration: "trusted_integration";
+                    user_api: "user_api";
+                }>;
+                version: z.ZodNullable<z.ZodObject<{
+                    kind: z.ZodEnum<{
+                        artifact_version: "artifact_version";
+                        branch_head: "branch_head";
+                        ci_run: "ci_run";
+                        git_commit: "git_commit";
+                        other: "other";
+                        pull_request_head: "pull_request_head";
+                        release_version: "release_version";
+                    }>;
+                    value: z.ZodString;
+                }, z.core.$strip>>;
+                observedAt: z.ZodString;
+                updatedAt: z.ZodString;
+                settledAt: z.ZodNullable<z.ZodString>;
+            }, z.core.$strip>>;
+            claimsTruncated: z.ZodBoolean;
+            match: z.ZodNullable<z.ZodObject<{
+                class: z.ZodEnum<{
+                    exact_subject: "exact_subject";
+                    fuzzy: "fuzzy";
+                    goal: "goal";
+                    title: "title";
+                }>;
+                field: z.ZodEnum<{
+                    claim_key: "claim_key";
+                    claim_label: "claim_label";
+                    goal: "goal";
+                    subject: "subject";
+                    title: "title";
+                }>;
+                scoreBand: z.ZodEnum<{
+                    exact: "exact";
+                    related: "related";
+                    strong: "strong";
+                }>;
+                claimId: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>>;
+            possibleOverlap: z.ZodBoolean;
+            advisoryOnly: z.ZodLiteral<true>;
+            noAdditionalAccess: z.ZodLiteral<true>;
+        }, z.core.$strict>;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+    }, z.core.$strip>>;
+    total: z.ZodNumber;
+    hasMore: z.ZodBoolean;
+    humanAdvisoriesEnabled: z.ZodOptional<z.ZodBoolean>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type AgentTopologyPageResponse = z.infer<typeof AgentTopologyPageResponse>;

package/dist/allowance-refusal.d.ts

@@ -0,0 +1,9 @@
+import type { AllowanceExhaustedRefusal } from "./usage-allowances.js";
+/** Select only public refusal fields, including from an API error's details.
+ * LimitDecision's allowed:false and transport/SQL diagnostics never cross out.
+ */
+export declare function parseAllowanceExhaustedRefusal(value: unknown): AllowanceExhaustedRefusal | null;
+/** Bounded, fixed remedies: a ceiling is not an exhausted billing source.
+ * Never interpolate arbitrary exception prose or a member identifier.
+ */
+export declare function allowanceExhaustedMessage(refusal: AllowanceExhaustedRefusal): string;