@kindgi/api 0.1.3 → 0.1.4-rc.1

package/src/eval-case-binding.ts

@@ -0,0 +1,71 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (C) 2026 Kindgi Inc.
+
+import type { Cursor, TenantId } from '@kindgi/types';
+
+import type { JudgedItem, JudgedRunContext, JudgedSubject } from './judgment-binding.js';
+
+/**
+ * Caller-plugged storage for the cases of an eval-suite version, kept
+ * apart from the version's `spec` because a set can hold hundreds of
+ * cases. A `judged` suite version's cases are built from judgments: each
+ * is a copy of one judged run (its input, what it read, the output that
+ * was judged) with the judgments of its items summed up. Copies, so a
+ * test set stays the same when judgments are removed or runs purged.
+ *
+ * Cases are written once, when the version is published, and removed
+ * with it.
+ */
+export interface EvalCaseStoreBinding {
+  /** Store a version's cases. Called once, right after the version is published. */
+  putCases(input: EvalCasePutInput): Promise<void>;
+  /** A version's cases, in the order they were stored, cursor-paginated. */
+  listCases(input: EvalCaseListInput): Promise<EvalCasePage>;
+}
+
+/** The judgments of one item of a case's output, summed up. */
+export interface JudgedItemSummary extends JudgedItem {
+  readonly yes: number;
+  readonly no: number;
+  /** The weight behind "yes" (an unclassified judgment counts 1). */
+  readonly yesWeight: number;
+  /** The weight behind all judgments of the item. */
+  readonly totalWeight: number;
+  /** The reasons given, newest first. */
+  readonly reasons: readonly { readonly verdict: 'yes' | 'no'; readonly reason: string }[];
+}
+
+/** One case of a `judged` suite: a copy of a judged run and what people said about it. */
+export interface JudgedEvalCase {
+  /** The judged run's id. */
+  readonly caseId: string;
+  /** What ran: the agent or flow at a version (the baseline when comparing to the recording). */
+  readonly subject: JudgedSubject;
+  readonly input: unknown;
+  /** What the turn read besides its input; absent when it wasn't captured. */
+  readonly context?: JudgedRunContext;
+  /** The output that was judged. */
+  readonly output: unknown;
+  readonly items: readonly JudgedItemSummary[];
+}
+
+export interface EvalCasePutInput {
+  readonly tenantId: TenantId;
+  readonly suiteId: string;
+  readonly version: string;
+  readonly cases: readonly JudgedEvalCase[];
+}
+
+export interface EvalCaseListInput {
+  readonly tenantId: TenantId;
+  readonly suiteId: string;
+  readonly version: string;
+  readonly cursor?: Cursor;
+  readonly limit: number;
+}
+
+export interface EvalCasePage {
+  readonly data: readonly JudgedEvalCase[];
+  readonly hasMore: boolean;
+  readonly nextCursor?: Cursor;
+}

package/src/eval-run-binding.ts

@@ -2,6 +2,7 @@
 // Copyright (C) 2026 Kindgi Inc.
 
 import type { AgentId } from '@kindgi/agents';
+import type { FlowVersionOverrides } from '@kindgi/flow';
 import type { Scope } from '@kindgi/platform';
 import type { Cursor, FlowId, ProjectId, RunId, Semver, TenantId, Timestamp } from '@kindgi/types';
 
@@ -105,6 +106,8 @@ export interface EvalRun {
   readonly result?: Readonly<Record<string, unknown>>;
   readonly error?: string;
   readonly correlationId?: string;
+  /** A comparison eval run's baseline, reads and repetitions. */
+  readonly comparison?: EvalComparison;
 }
 
 export interface EvalRunFilter {
@@ -116,6 +119,41 @@ export interface EvalRunFilter {
   readonly to?: Timestamp;
 }
 
+/**
+ * What a comparison eval run compares the candidate against:
+ *   - `'recorded'`: the output each case recorded (what was judged);
+ *   - `{ agentId, version }`: that version, replayed under the same rules;
+ *   - `{ live }`: the version live in a scope (a project, segments).
+ */
+export type EvalBaseline =
+  | 'recorded'
+  | { readonly agentId: AgentId; readonly version: Semver }
+  | {
+      readonly live: {
+        readonly projectId?: ProjectId;
+        readonly segments?: Readonly<Record<string, string>>;
+      };
+    };
+
+/** Whether replayed reads use the past run's results when it has them, or run live. */
+export type EvalReads = 'recorded' | 'live';
+
+/** How a comparison eval run runs its cases (absent: the run isn't a comparison). */
+export interface EvalComparison {
+  readonly baseline: EvalBaseline;
+  readonly reads: EvalReads;
+  /** How many times each case runs (1–10); with more than 1, the summary shows the spread. */
+  readonly repetitions: number;
+  /** How many ranked items `weightedPrecisionAtK` looks at (1–100). */
+  readonly k: number;
+  /**
+   * For a flow candidate: agents and tools its replays run at other exact
+   * versions than the flow version's pins ("this flow, with `acme.scorer`
+   * at 0.4.0"), without publishing a new flow version.
+   */
+  readonly versions?: FlowVersionOverrides;
+}
+
 export interface EvalRunStartInput {
   readonly tenantId: TenantId;
   /**
@@ -130,6 +168,8 @@ export interface EvalRunStartInput {
   readonly flowRef?: FlowRef;
   readonly dryRun?: boolean;
   readonly correlationId?: string;
+  /** Set for a comparison eval run (a `judged` suite): its baseline, reads and repetitions. */
+  readonly comparison?: EvalComparison;
 }
 
 /**

package/src/eval-run-dispatcher.ts

@@ -3,10 +3,14 @@
 
 import { randomUUID } from 'node:crypto';
 
-import type { RunId, TenantId, Timestamp } from '@kindgi/types';
+import type { ReplayTurnReport } from '@kindgi/agents';
+import type { FlowVersionOverrides } from '@kindgi/flow';
+import type { RunReplayRef } from '@kindgi/runtime';
+import type { ProjectId, RunId, TenantId, Timestamp } from '@kindgi/types';
 
 import type {
   AgentRef,
+  EvalComparison,
   EvalRun,
   EvalRunBinding,
   EvalRunCancelInput,
@@ -50,6 +54,18 @@ export interface EvalRunSubjectInvokeInput {
   readonly input: unknown;
   readonly dryRun: boolean;
   readonly abortSignal: AbortSignal;
+  /** The eval run's project: where the subject runs. */
+  readonly projectId?: ProjectId;
+  /**
+   * Set when the subject re-runs a past run (a comparison eval run): the
+   * run is a replay of `of` for the eval run, under the replay rules
+   * (`InvokeAgentInput.replay`).
+   */
+  readonly replay?: RunReplayRef;
+  /** The conversation before the past turn, oldest first: a replayed turn starts from it. */
+  readonly history?: readonly unknown[];
+  /** A flow target's agents and tools at other exact versions (`EvalComparison.versions`). */
+  readonly versions?: FlowVersionOverrides;
 }
 
 export interface EvalRunSubjectInvokeOutcome {
@@ -57,6 +73,22 @@ export interface EvalRunSubjectInvokeOutcome {
   readonly error?: string;
   readonly costUsd?: number;
   readonly durationMs?: number;
+  /** The run the subject ran in. */
+  readonly runId?: RunId;
+  /** A replay's report: each tool call and what happened to it (`AgentTurnResult.replay`). */
+  readonly replay?: ReplayTurnReport;
+  /** The provider and model that answered. */
+  readonly provider?: { readonly id: string; readonly model: string };
+  /**
+   * Set when a replayed flow stopped at a tool call the replay refused (a
+   * write the past run didn't make): no output, and what it would have
+   * done. Not an error: the replay did what it's meant to.
+   */
+  readonly stopped?: {
+    readonly toolId: string;
+    readonly arguments: unknown;
+    readonly reason?: string;
+  };
 }
 
 /**
@@ -100,6 +132,10 @@ export interface DispatchContext {
   readonly dryRun: boolean;
   readonly abortSignal: AbortSignal;
   readonly subject: EvalSubjectInvoker;
+  /** The eval run's project. */
+  readonly projectId?: ProjectId;
+  /** A comparison eval run's baseline, reads and repetitions. */
+  readonly comparison?: EvalComparison;
   onProgress(perCase: Readonly<Record<string, unknown>>): void;
 }
 
@@ -113,6 +149,7 @@ export interface EvalRunDispatcher {
   validate?(
     suite: EvalSuite,
     target: AgentRef | FlowRef,
+    comparison?: EvalComparison,
   ): { kind: 'ok' } | { kind: 'err'; message: string };
   dispatch(ctx: DispatchContext): Promise<DispatchResult>;
 }
@@ -311,26 +348,13 @@ export function createInProcessEvalRunBinding(
         };
       }
       if (dispatcher.validate !== undefined) {
-        const v = dispatcher.validate(suite, target);
+        const v = dispatcher.validate(suite, target, input.comparison);
         if (v.kind === 'err') {
           return { kind: 'dispatcher-input-invalid', message: v.message };
         }
       }
       const runId = randomUUID() as unknown as RunId;
-      const startedAt = now().toISOString() as unknown as Timestamp;
-      const record: EvalRun = {
-        runId,
-        tenantId: input.tenantId,
-        suiteId: suite.id,
-        suiteVersion: suite.version,
-        kind: suite.kind,
-        ...(input.agentRef !== undefined && { agentRef: input.agentRef }),
-        ...(input.flowRef !== undefined && { flowRef: input.flowRef }),
-        status: 'running' as EvalRunStatus,
-        dryRun: input.dryRun === true,
-        startedAt,
-        ...(input.correlationId !== undefined && { correlationId: input.correlationId }),
-      };
+      const record = newRunRecord(input, suite, runId, now());
       setRun(record);
       const controller = new AbortController();
       controllers.set(runId as unknown as string, controller);
@@ -349,6 +373,8 @@ export function createInProcessEvalRunBinding(
             dryRun: input.dryRun === true,
             abortSignal: controller.signal,
             subject: options.subject,
+            projectId: input.projectId,
+            ...(input.comparison !== undefined && { comparison: input.comparison }),
             onProgress: (perCaseEntry: Readonly<Record<string, unknown>>) => {
               const current = runs.get(runId as unknown as string);
               if (current === undefined) return;
@@ -489,6 +515,24 @@ export function createInProcessEvalRunBinding(
   };
 }
 
+/** A started run's row: `running`, with what it runs and how. */
+function newRunRecord(input: EvalRunStartInput, suite: EvalSuite, runId: RunId, at: Date): EvalRun {
+  return {
+    runId,
+    tenantId: input.tenantId,
+    suiteId: suite.id,
+    suiteVersion: suite.version,
+    kind: suite.kind,
+    ...(input.agentRef !== undefined && { agentRef: input.agentRef }),
+    ...(input.flowRef !== undefined && { flowRef: input.flowRef }),
+    status: 'running',
+    dryRun: input.dryRun === true,
+    startedAt: at.toISOString() as unknown as Timestamp,
+    ...(input.correlationId !== undefined && { correlationId: input.correlationId }),
+    ...(input.comparison !== undefined && { comparison: input.comparison }),
+  };
+}
+
 function isTerminal(status: EvalRunStatus): boolean {
   return status === 'completed' || status === 'failed' || status === 'cancelled';
 }

package/src/eval-suite-binding.ts

@@ -100,6 +100,8 @@ export const EVAL_KINDS = [
   'human-review',
   'benchmark',
   'custom',
+  /** Built from judgments of past runs: cases are copies of judged runs (`EvalCaseStoreBinding`). */
+  'judged',
 ] as const;
 export type EvalKind = (typeof EVAL_KINDS)[number];
 

package/src/flow-binding.ts

@@ -6,6 +6,8 @@ import type { Flow } from '@kindgi/flow';
 import type { Scope } from '@kindgi/platform';
 import type { Cursor, FlowId, ProjectId, TenantId } from '@kindgi/types';
 
+import type { RegistryReadOnly } from './registry-read-only.js';
+
 /**
  * Caller-plugged surface for the flow catalog. Mirrors
  * `AgentRegistryBinding` 1:1 — the API package does NOT own registry
@@ -26,6 +28,13 @@ import type { Cursor, FlowId, ProjectId, TenantId } from '@kindgi/types';
  * cursor round-trips as a string; it never inspects the payload.
  */
 export interface FlowRegistryBinding {
+  /**
+   * Set when this registry takes no writes (under `kindgi dev`, the
+   * pack's files are the source of its flows): every write is refused
+   * with `409 registry-read-only` and this reason, before the binding is
+   * called. See `RegistryReadOnly`.
+   */
+  readonly readOnly?: RegistryReadOnly;
   /**
    * Cursor-paginated list of flows (latest version per id, sorted by
    * flow id ascending). Optional `nameFilter` is a prefix match on the
@@ -39,11 +48,12 @@ export interface FlowRegistryBinding {
    */
   get(input: FlowGetInput): Promise<Flow | null>;
   /**
-   * Specific `(flowId, version)` lookup, or `null` if unknown.
-   * Returns tombstoned versions too — provenance paths need to
-   * resolve historical run references.
+   * Specific `(flowId, version)` lookup, or `null` if unknown. Returns
+   * unregistered (tombstoned) versions too, with `unregisteredAt` set:
+   * a resumed run and provenance read them, while a new run that names
+   * one is refused.
    */
-  getVersion(input: FlowGetVersionInput): Promise<Flow | null>;
+  getVersion(input: FlowGetVersionInput): Promise<FlowVersionRecord | null>;
   /**
    * Head-row existence check. Lets `GET /v1/flows/{id}` distinguish
    * `410 gone` (identity exists, no active version) from `404 not-
@@ -79,6 +89,12 @@ export interface FlowRegistryBinding {
   reinstateVersion(input: FlowReinstateVersionInput): Promise<FlowReinstateVersionOutcome>;
 }
 
+/** A flow version as `getVersion` reads it: `unregisteredAt` is set when it's unregistered. */
+export type FlowVersionRecord = Flow & {
+  /** ISO-8601; present only on an unregistered version. */
+  readonly unregisteredAt?: string;
+};
+
 export interface FlowListInput {
   readonly tenantId: TenantId;
   readonly limit: number;

package/src/flow-pins.ts

@@ -0,0 +1,113 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (C) 2026 Kindgi Inc.
+
+import type { AgentId } from '@kindgi/agents';
+import type { TupleEnqueueHook } from '@kindgi/authz';
+import { type Flow, type FlowPins, flowPinsDigest, flowRefs } from '@kindgi/flow';
+import { latestVersion } from '@kindgi/tools';
+import type { Cursor, FlowId, ProjectId, TenantId, ToolId } from '@kindgi/types';
+
+import type { AgentRegistryBinding } from './agent-binding.js';
+import { type UnpinnableRef, activeToolVersions } from './agent-pins.js';
+import { type DeployedVersionOutcome, deployVersion } from './deploy-versions.js';
+import type { FlowRegistryBinding } from './flow-binding.js';
+import type { ToolRegistryBinding } from './tool-binding.js';
+
+export type FlowPinsOutcome =
+  | { readonly kind: 'ok'; readonly pins: FlowPins }
+  | { readonly kind: 'unpinnable'; readonly issues: readonly UnpinnableRef[] };
+
+/**
+ * Pin a flow version when it's published: each tool it runs, and each
+ * agent it runs at no named version, to its latest active version now
+ * (what a run would have bound), so every run of the version uses those.
+ * A tool or agent with no published version makes the flow unpinnable:
+ * the caller refuses the publish, naming each, rather than store a
+ * partly pinned version.
+ */
+export async function resolveFlowPins(
+  tools: ToolRegistryBinding,
+  agents: AgentRegistryBinding,
+  tenantId: TenantId,
+  flow: Flow,
+): Promise<FlowPinsOutcome> {
+  const refs = flowRefs(flow);
+  const pinned: { tools: Record<string, string>; agents: Record<string, string> } = {
+    tools: {},
+    agents: {},
+  };
+  const issues: UnpinnableRef[] = [];
+  for (const id of refs.tools) {
+    const latest = latestVersion(await activeToolVersions(tools, tenantId, id as ToolId));
+    if (latest !== undefined) pinned.tools[id] = latest;
+    else
+      issues.push({
+        path: '/nodes',
+        message: `tool "${id}" has no published version; publish the tool first`,
+      });
+  }
+  for (const id of refs.agents) {
+    const latest = await agents.get({ tenantId, agentId: id as AgentId });
+    if (latest !== null) pinned.agents[id] = latest.version as unknown as string;
+    else
+      issues.push({
+        path: '/nodes',
+        message: `agent "${id}" has no published version; publish the agent first`,
+      });
+  }
+  if (issues.length > 0) return { kind: 'unpinnable', issues };
+  return { kind: 'ok', pins: pinned };
+}
+
+export interface PublishDeployedFlowInput {
+  readonly flows: FlowRegistryBinding;
+  readonly tenantId: TenantId;
+  readonly projectId: ProjectId;
+  /** The flow as the pack defines it, with no pins. */
+  readonly flow: Flow;
+  readonly pins: FlowPins;
+  readonly enqueueTuples: TupleEnqueueHook;
+}
+
+/** Register a deployed flow with its pins, by the deploy rule (`deployVersion`). */
+export async function publishDeployedFlow(
+  input: PublishDeployedFlowInput,
+): Promise<DeployedVersionOutcome> {
+  const { flows, tenantId, projectId, flow, pins, enqueueTuples } = input;
+  return deployVersion<Flow>({
+    label: `flow "${flow.id as unknown as string}"`,
+    definition: flow,
+    pins,
+    pinsDigest: flowPinsDigest(pins),
+    existing: await allFlowVersions(flows, tenantId, flow.id),
+    publish: async (version) => {
+      const outcome = await flows.publish({ tenantId, projectId, flow: version, enqueueTuples });
+      if (outcome.kind === 'ok') return 'ok';
+      return outcome.kind === 'project-not-found' ? 'skipped' : 'taken';
+    },
+  });
+}
+
+/** Page size for reading a flow's versions. */
+const VERSIONS_PAGE = 200;
+
+/** Every active version of a flow. */
+async function allFlowVersions(
+  flows: FlowRegistryBinding,
+  tenantId: TenantId,
+  flowId: FlowId,
+): Promise<readonly Flow[]> {
+  const versions: Flow[] = [];
+  let cursor: Cursor | undefined;
+  do {
+    const page = await flows.listVersions({
+      tenantId,
+      flowId,
+      limit: VERSIONS_PAGE,
+      ...(cursor !== undefined && { cursor }),
+    });
+    versions.push(...page.data);
+    cursor = page.nextCursor;
+  } while (cursor !== undefined);
+  return versions;
+}

package/src/guardrail-binding.ts

@@ -6,6 +6,8 @@ import type { Guardrail } from '@kindgi/guardrails';
 import type { Scope } from '@kindgi/platform';
 import type { Cursor, GuardrailId, ProjectId, TenantId } from '@kindgi/types';
 
+import type { RegistryReadOnly } from './registry-read-only.js';
+
 /**
  * Caller-plugged surface for the guardrail catalog. Same shape as
  * `AgentRegistryBinding` / `ToolRegistryBinding`: the API package does
@@ -27,6 +29,13 @@ import type { Cursor, GuardrailId, ProjectId, TenantId } from '@kindgi/types';
  * inspects the payload.
  */
 export interface GuardrailRegistryBinding {
+  /**
+   * Set when this registry takes no writes (under `kindgi dev`, the
+   * pack's files are the source of its guardrails): every write is refused
+   * with `409 registry-read-only` and this reason, before the binding is
+   * called. See `RegistryReadOnly`.
+   */
+  readonly readOnly?: RegistryReadOnly;
   /**
    * Cursor-paginated list of guardrails sorted by id ascending.
    * Optional `nameFilter` is a prefix match on the guardrail id —

package/src/handler-binding.ts

@@ -2,6 +2,7 @@
 // Copyright (C) 2026 Kindgi Inc.
 
 import type { AgentId } from '@kindgi/agents';
+import type { FlowVersionOverrides } from '@kindgi/flow';
 import type { FlowId, ProjectId, RunId, Semver, TenantId } from '@kindgi/types';
 
 /**
@@ -107,6 +108,8 @@ export interface InvokeFlowBindingInput {
    * can't run in the background may treat `false` like `true`.
    */
   readonly wait?: boolean;
+  /** Agents and tools to run at other exact versions than the flow version's pins (`RunFlowInput.versions`). */
+  readonly versions?: FlowVersionOverrides;
 }
 
 export type RunHandlerOutcome =

package/src/index.ts

@@ -233,11 +233,13 @@ export type {
   AgentPublishInput,
   AgentPublishOutcome,
   AgentRegistryBinding,
+  AgentVersionRecord,
   AgentReinstateVersionInput,
   AgentReinstateVersionOutcome,
   AgentUnregisterInput,
   AgentUnregisterOutcome,
 } from './agent-binding.js';
+export type { RegistryReadOnly } from './registry-read-only.js';
 export type {
   FlowGetInput,
   FlowGetVersionInput,
@@ -247,6 +249,7 @@ export type {
   FlowPublishInput,
   FlowPublishOutcome,
   FlowRegistryBinding,
+  FlowVersionRecord,
   FlowReinstateVersionInput,
   FlowReinstateVersionOutcome,
   FlowUnregisterInput,
@@ -309,7 +312,7 @@ export {
   stdioRefusal,
 } from './tenant-host-access.js';
 export type { HostReach, TenantHostAccess } from './tenant-host-access.js';
-export { POLICY_KINDS } from '@kindgi/policy-contract';
+export { APPLIED_POLICY_KINDS, POLICY_KINDS } from '@kindgi/policy-contract';
 export type {
   Policy,
   PolicyGetInput,
@@ -328,6 +331,61 @@ export type {
   PolicyVersionPage,
   PolicyVersionRow,
 } from '@kindgi/policy-contract';
+export { JUDGE_CLASS_SCOPE_KINDS, VERDICTS, judgeClassApplies } from './judgment-binding.js';
+export type {
+  EvalCaseListInput,
+  EvalCasePage,
+  EvalCasePutInput,
+  EvalCaseStoreBinding,
+  JudgedEvalCase,
+  JudgedItemSummary,
+} from './eval-case-binding.js';
+export { MAX_JUDGED_CASES } from './routes/judged-suites.js';
+export { MAX_JUDGED_HISTORY } from './routes/judgment-context.js';
+export type {
+  JudgeClass,
+  JudgeClassCreateInput,
+  JudgeClassCreateOutcome,
+  JudgeClassGetInput,
+  JudgeClassListInput,
+  JudgeClassPage,
+  JudgeClassScope,
+  JudgeClassScopeKind,
+  JudgeClassUpdateInput,
+  JudgedItem,
+  JudgedFlowContext,
+  JudgedFlowStep,
+  JudgedRunContext,
+  JudgedToolCall,
+  JudgedRunCopy,
+  JudgedRunListInput,
+  JudgedRunPage,
+  JudgedRunWithJudgments,
+  JudgedSubject,
+  Judgment,
+  JudgmentAssertedBy,
+  JudgmentGetInput,
+  JudgmentListInput,
+  JudgmentPage,
+  JudgmentRecordInput,
+  JudgmentRegistryBinding,
+  JudgmentWithCopies,
+  Verdict,
+} from './judgment-binding.js';
+export { resolvePointer } from './routes/judgments.js';
+export type {
+  BlockGetInput,
+  BlockGetVersionInput,
+  BlockListInput,
+  BlockListVersionsInput,
+  BlockPage,
+  BlockPublishInput,
+  BlockPublishOutcome,
+  BlockRecord,
+  BlockRegistryBinding,
+  BlockReinstateOutcome,
+  BlockVersionInput,
+} from './block-binding.js';
 export { EVAL_KINDS } from './eval-suite-binding.js';
 export type {
   EvalKind,
@@ -348,6 +406,9 @@ export type {
 export { EVAL_RUN_STATUSES } from './eval-run-binding.js';
 export type {
   AgentRef,
+  EvalBaseline,
+  EvalComparison,
+  EvalReads,
   EvalRun,
   EvalRunBinding,
   EvalRunCancelInput,
@@ -379,7 +440,27 @@ export type {
   EvalSubjectInvoker,
   InProcessEvalRunBindingOptions,
 } from './eval-run-dispatcher.js';
-export { COST_GROUP_DIMENSIONS } from './cost-binding.js';
+export { DEFAULT_COMPARISON, createJudgedDispatcher } from './judged-dispatcher.js';
+export type {
+  ComparisonBaselineSummary,
+  ComparisonMetric,
+  JudgedCaseResult,
+  JudgedComparisonSummary,
+  JudgedDispatcherOptions,
+} from './judged-dispatcher.js';
+export { itemChanges, matchJudged, outputItems, scoreItems, valueAt } from './judged-items.js';
+export type {
+  ItemChanges,
+  ItemJudgments,
+  MatchedItem,
+  OutputItem,
+  OutputScore,
+} from './judged-items.js';
+export {
+  COST_AGGREGATE_DEFAULT_LIMIT,
+  COST_AGGREGATE_MAX_LIMIT,
+  COST_GROUP_DIMENSIONS,
+} from './cost-binding.js';
 export type {
   CostAggregateGroup,
   CostAggregateInput,
@@ -477,7 +558,10 @@ export type {
   DeploymentGetInput,
   DeploymentListInput,
   DeploymentPage,
+  DeployedAgent,
+  DeployedFlow,
   DeployedPrimitive,
+  DeployedVersion,
   DeploymentContents,
   DeploymentPrimitiveCounts,
   DeploymentRegisterInput,