@tangle-network/agent-interface 0.33.0 → 0.35.0

package/dist/agent-profile-improvement.d.ts

@@ -0,0 +1,140 @@
+import type { AgentCandidateBenchmarkDimension, AgentCandidateBenchmarkGraderIdentity, AgentCandidateDigestAlgorithm, AgentCandidateEvaluationPolicy, AgentCandidateExecutionLimits, AgentCandidateFixedSpend, AgentCandidateLineage, AgentCandidateResolvedModel, AgentImprovementMeasuredComparisonBase, Sha256Digest } from "./agent-candidate.js";
+import type { AgentImprovementSource } from "./agent-improvement-source.js";
+import type { AgentProfileDiff } from "./profile-diff.js";
+/** An access-controlled evidence record emitted by a host-owned profile run. */
+export interface AgentProfileImprovementEvidence {
+    kind: string;
+    identity: string;
+    digest: Sha256Digest;
+}
+/** One profile task whose content and evaluator are frozen before either arm runs. */
+export interface AgentProfileImprovementTaskMaterial {
+    kind: "agent-profile-improvement-task";
+    digestAlgorithm: AgentCandidateDigestAlgorithm;
+    scenario: {
+        id: string;
+        kind: string;
+        digest: Sha256Digest;
+    };
+    grader: AgentCandidateBenchmarkGraderIdentity;
+    model: AgentCandidateResolvedModel;
+    limits: AgentCandidateExecutionLimits;
+}
+export interface AgentProfileImprovementTask extends AgentProfileImprovementTaskMaterial {
+    digest: Sha256Digest;
+}
+/** The full paired denominator for host-owned profile executions. */
+export interface AgentProfileImprovementSuiteMaterial {
+    kind: "agent-profile-improvement-suite";
+    digestAlgorithm: AgentCandidateDigestAlgorithm;
+    splitDigest: Sha256Digest;
+    taskDigests: [Sha256Digest, ...Sha256Digest[]];
+    reps: number;
+    /** Task-major, then repetition-major. */
+    seeds: [number, ...number[]];
+}
+export interface AgentProfileImprovementSuite extends AgentProfileImprovementSuiteMaterial {
+    digest: Sha256Digest;
+}
+export interface AgentProfileImprovementSuiteInputs {
+    suite: AgentProfileImprovementSuite;
+    tasks: [AgentProfileImprovementTask, ...AgentProfileImprovementTask[]];
+}
+/** The complete profile state that actually runs. */
+export interface AgentProfileImprovementArm {
+    stateDigest: Sha256Digest;
+}
+/**
+ * Ordered portable profile patches retained for review and activation.
+ *
+ * Applying the steps in order matters: a full resource replacement is a reset
+ * followed by a replacement step. Prompt and inline skill content can be
+ * sensitive, so the product that persists this value owns access control and
+ * redaction.
+ */
+export type AgentProfileImprovementChange = [AgentProfileDiff, ...AgentProfileDiff[]];
+/** A measured comparison of two states of one host-owned agent profile. */
+export interface AgentProfileImprovementExperimentMaterial {
+    kind: "agent-profile-improvement-experiment";
+    digestAlgorithm: AgentCandidateDigestAlgorithm;
+    source: AgentImprovementSource;
+    baseline: AgentProfileImprovementArm;
+    candidate: AgentProfileImprovementArm;
+    change: AgentProfileImprovementChange;
+    candidateLineage: AgentCandidateLineage;
+    benchmark: AgentProfileImprovementSuiteInputs;
+    policy: AgentCandidateEvaluationPolicy;
+}
+export interface AgentProfileImprovementExperiment extends AgentProfileImprovementExperimentMaterial {
+    digest: Sha256Digest;
+}
+/** Exact identity for one profile attempt in a frozen experiment. */
+export interface AgentProfileImprovementRunCellMaterial {
+    kind: "agent-profile-improvement-run-cell";
+    experimentDigest: Sha256Digest;
+    arm: "baseline" | "candidate";
+    stateDigest: Sha256Digest;
+    suiteDigest: Sha256Digest;
+    taskDigest: Sha256Digest;
+    taskIndex: number;
+    repetition: number;
+    seed: number;
+    attempt: number;
+}
+export interface AgentProfileImprovementRunCell extends AgentProfileImprovementRunCellMaterial {
+    digest: Sha256Digest;
+}
+/** Verifiable output from one profile execution and its frozen evaluator. */
+export interface AgentProfileImprovementRunReceipt {
+    kind: "agent-profile-improvement-run";
+    digestAlgorithm: AgentCandidateDigestAlgorithm;
+    executionId: string;
+    runCell: AgentProfileImprovementRunCell;
+    runRecord: AgentProfileImprovementEvidence;
+    billing: [AgentProfileImprovementEvidence, ...AgentProfileImprovementEvidence[]];
+    timing: {
+        startedAtMs: number;
+        endedAtMs: number;
+        durationMs: number;
+    };
+    steps: number;
+    resolvedModel: AgentCandidateResolvedModel;
+    limits: AgentCandidateExecutionLimits;
+    usage: AgentCandidateFixedSpend;
+    trace: {
+        evidence: AgentProfileImprovementEvidence;
+        eventCount: number;
+        modelCallCount: number;
+    };
+    output: AgentProfileImprovementEvidence;
+    outcome: {
+        status: "succeeded";
+    } | {
+        status: "failed";
+        code: string;
+        message: string;
+    };
+    grading: {
+        grader: AgentCandidateBenchmarkGraderIdentity;
+        evidence: AgentProfileImprovementEvidence;
+        timing: {
+            startedAtMs: number;
+            endedAtMs: number;
+            durationMs: number;
+        };
+        usage: AgentCandidateFixedSpend;
+        score: number;
+        passed: boolean;
+        dimensions: AgentCandidateBenchmarkDimension[];
+    };
+    digest: Sha256Digest;
+}
+/** One paired result from the exact same task, seed, and evaluator. */
+export interface AgentProfileImprovementMeasurement {
+    baseline: AgentProfileImprovementRunReceipt;
+    candidate: AgentProfileImprovementRunReceipt;
+}
+/** Portable paired comparison from ordinary profile executions. */
+export interface AgentProfileImprovementMeasuredComparison extends AgentImprovementMeasuredComparisonBase<AgentProfileImprovementExperiment, AgentProfileImprovementMeasurement, "agent-profile-improvement-measured-comparison"> {
+    kind: "agent-profile-improvement-measured-comparison";
+}

package/dist/agent-profile-improvement.js

@@ -0,0 +1 @@
+export {};

package/dist/agent-profile.d.ts

@@ -3,8 +3,8 @@
  *
  * These model portable agent intent at the application boundary. Individual
  * backends translate this shape into their own native profile/configuration
- * formats internally. This is the canonical home; `@tangle-network/sandbox`
- * re-exports these symbols for backward compatibility.
+ * formats internally. This package is the canonical public home for these
+ * symbols.
  */
 import type { HarnessType } from "./harness.js";
 /**

package/dist/agent-profile.js

@@ -3,8 +3,8 @@
  *
  * These model portable agent intent at the application boundary. Individual
  * backends translate this shape into their own native profile/configuration
- * formats internally. This is the canonical home; `@tangle-network/sandbox`
- * re-exports these symbols for backward compatibility.
+ * formats internally. This package is the canonical public home for these
+ * symbols.
  */
 /**
  * Helper for creating typed inline resource refs.

package/dist/harness-capabilities.d.ts

@@ -1,5 +1,5 @@
 import type { ReasoningEffort } from "./agent-profile.js";
-import { type HarnessType } from "./harness.js";
+import type { HarnessType } from "./harness.js";
 /**
  * The unified harness capability layer — the single source of truth for:
  *   1. harness ↔ model compatibility (which models a harness can run), and

package/dist/harness-capabilities.js

@@ -1,4 +1,3 @@
-import { canonicalizeHarness } from "./harness.js";
 /**
  * The unified harness capability layer — the single source of truth for:
  *   1. harness ↔ model compatibility (which models a harness can run), and
@@ -28,8 +27,7 @@ export const reasoningLadder = [
 // ── Harness ↔ model compatibility ────────────────────────────────────────────
 /**
  * Provider prefixes a harness is vendor-locked to (canonical-id prefix, e.g. `anthropic`, `openai`).
- * A harness with no entry is router-backed: it runs any model. Keyed by the BASE runner — aliases
- * (`claude`/`claudish`/`kimi`) resolve through `canonicalizeHarness` first.
+ * A harness with no entry is router-backed: it runs any model.
  *
  * `nanoclaw` is deliberately absent despite the "claw" name: its runner routes every provider through
  * the Tangle router (canonical model id straight to the gateway), so it is router-backed like
@@ -47,7 +45,7 @@ export function modelProvider(modelId) {
 }
 /** The providers a harness is locked to, or `null` when it is router-backed (any model). */
 export function harnessProviders(harness) {
-    return harnessProviderLock[canonicalizeHarness(harness)] ?? null;
+    return harnessProviderLock[harness] ?? null;
 }
 /**
  * Whether a harness can run a model. Router-backed harnesses (no provider lock) accept anything;
@@ -76,7 +74,7 @@ export function preferredHarnessForModel(modelId) {
 /**
  * Per-harness ranking patterns for {@link snapModelToHarness}, best first; within one pattern the
  * highest version wins (numeric-aware). Only vendor-locked harnesses need an entry — a router-backed
- * harness never snaps (it runs the model as-is). Keyed by the BASE runner (aliases canonicalized).
+ * harness never snaps (it runs the model as-is).
  */
 const harnessPreferredModelPatterns = {
     "claude-code": [
@@ -101,7 +99,7 @@ const numericDesc = new Intl.Collator(undefined, {
 export function snapModelToHarness(harness, modelId, candidateIds) {
     if (harnessSupportsModel(harness, modelId))
         return modelId;
-    const patterns = harnessPreferredModelPatterns[canonicalizeHarness(harness)] ?? [];
+    const patterns = harnessPreferredModelPatterns[harness] ?? [];
     for (const pattern of patterns) {
         const matches = candidateIds
             .filter((id) => pattern.test(id))
@@ -164,11 +162,10 @@ const harnessReasoningCeiling = {
 /** The reasoning efforts a harness can express, independent of model — its explicit override set, or
  *  `none` up to its ceiling (default `ultracode` for router/model-driven harnesses). */
 export function harnessReasoningEfforts(harness) {
-    const canonical = canonicalizeHarness(harness);
-    const override = harnessReasoningEffortsOverride[canonical];
+    const override = harnessReasoningEffortsOverride[harness];
     if (override)
         return override;
-    const ceiling = harnessReasoningCeiling[canonical] ?? "ultracode";
+    const ceiling = harnessReasoningCeiling[harness] ?? "ultracode";
     return reasoningLadder.slice(0, reasoningLadder.indexOf(ceiling) + 1);
 }
 /**
@@ -191,7 +188,7 @@ export function reasoningEffortsFor(harness, model) {
 /**
  * Harnesses whose runner DROPS a per-turn selector — grounded in the cli-bridge adapter audit, NOT a
  * guess. Most harnesses honor both selectors, so only the exceptions are listed; a harness absent from
- * a set honors that selector. Keyed by the BASE runner (aliases canonicalized).
+ * a set honors that selector.
  *
  *   - model dropped:  `amp` (own agent picks the model), `openclaw` (dispatcher routes by its own
  *     config), `nanoclaw` (socket-bridge runner is config/env-driven).
@@ -215,11 +212,11 @@ const harnessIgnoresEffort = new Set([
 ]);
 /** Whether the harness's runner honors a per-turn MODEL override (vs. picking the model itself). */
 export function harnessHonorsModel(harness) {
-    return !harnessIgnoresModel.has(canonicalizeHarness(harness));
+    return !harnessIgnoresModel.has(harness);
 }
 /** Whether the harness's runner honors a reasoning-EFFORT override (vs. dropping it). */
 export function harnessHonorsEffort(harness) {
-    return !harnessIgnoresEffort.has(canonicalizeHarness(harness));
+    return !harnessIgnoresEffort.has(harness);
 }
 /** Whether the harness honors BOTH chat selectors — i.e. the model and effort pickers are live. */
 export function harnessHonorsSelectors(harness) {

package/dist/harness.d.ts

@@ -14,20 +14,15 @@ import { z } from "zod";
  * a one-shot) with no full coding-agent harness. The rest are full agentic harnesses run in a
  * sandbox or locally via the CLI bridge.
  *
- * Some values are input aliases that collapse to a base runner (`claude`/`claudish` → `claude-code`,
- * `kimi` → `kimi-code`); normalize with {@link canonicalizeHarness} before keying per-runner config.
  */
-export type HarnessType = "claude-code" | "claude" | "claudish" | "nanoclaw" | "codex" | "opencode" | "kimi-code" | "kimi" | "pi" | "gemini" | "hermes" | "openclaw" | "amp" | "factory-droids" | "acp" | "cli-base";
+export type HarnessType = "claude-code" | "nanoclaw" | "codex" | "opencode" | "kimi-code" | "pi" | "gemini" | "hermes" | "openclaw" | "amp" | "factory-droids" | "acp" | "cli-base";
 /** Runtime validator for {@link HarnessType}. Kept in lockstep with the type by the drift guard below. */
 export declare const harnessTypeSchema: z.ZodEnum<{
     "claude-code": "claude-code";
-    claude: "claude";
-    claudish: "claudish";
     nanoclaw: "nanoclaw";
     codex: "codex";
     opencode: "opencode";
     "kimi-code": "kimi-code";
-    kimi: "kimi";
     pi: "pi";
     gemini: "gemini";
     hermes: "hermes";
@@ -37,7 +32,3 @@ export declare const harnessTypeSchema: z.ZodEnum<{
     acp: "acp";
     "cli-base": "cli-base";
 }>;
-/** Input alias → canonical base runner. Aliases accept legacy/shorthand harness names. */
-export declare const harnessAliases: Partial<Record<HarnessType, HarnessType>>;
-/** Collapse an alias to its base runner (idempotent on canonical values). */
-export declare function canonicalizeHarness(harness: HarnessType): HarnessType;

package/dist/harness.js

@@ -2,13 +2,10 @@ import { z } from "zod";
 /** Runtime validator for {@link HarnessType}. Kept in lockstep with the type by the drift guard below. */
 export const harnessTypeSchema = z.enum([
     "claude-code",
-    "claude",
-    "claudish",
     "nanoclaw",
     "codex",
     "opencode",
     "kimi-code",
-    "kimi",
     "pi",
     "gemini",
     "hermes",
@@ -18,15 +15,5 @@ export const harnessTypeSchema = z.enum([
     "acp",
     "cli-base",
 ]);
-/** Input alias → canonical base runner. Aliases accept legacy/shorthand harness names. */
-export const harnessAliases = {
-    claude: "claude-code",
-    claudish: "claude-code",
-    kimi: "kimi-code",
-};
-/** Collapse an alias to its base runner (idempotent on canonical values). */
-export function canonicalizeHarness(harness) {
-    return harnessAliases[harness] ?? harness;
-}
 const _harnessSchemaMatchesType = true;
 void _harnessSchemaMatchesType;

package/dist/index.d.ts

@@ -157,7 +157,7 @@ export declare function normalizeInputParts(input: {
 export declare function renderInputPartsAsText(parts: InputPart[]): string;
 /**
  * The primary event for all part updates from OpenCode.
- * This is the canonical event - use this instead of legacy events.
+ * This is the canonical event for all part updates.
  */
 export type MessagePartUpdatedEvent = {
     type: "message.part.updated";
@@ -613,7 +613,14 @@ export interface SdkProviderAdapter {
 export * from "./interaction.js";
 export * from "./agent-candidate.js";
 export * from "./agent-candidate-schema.js";
+export type { Sha256Digest } from "./agent-candidate.js";
+export { canonicalCandidateBytes, canonicalCandidateDigest, canonicalCandidateJson, sha256Bytes, sha256DigestSchema, sha256Utf8, } from "./agent-candidate-schema-common.js";
 export * from "./agent-candidate-promotion-schema.js";
+export { agentCandidateEvaluationPolicySchema } from "./agent-improvement-measurement-schema.js";
+export * from "./agent-improvement-source.js";
+export * from "./agent-profile-improvement.js";
+export * from "./agent-profile-improvement-schema.js";
+export * from "./agent-execution-limits.js";
 export * from "./agent-profile.js";
 export * from "./certified-context.js";
 export * from "./profile-diff.js";

package/dist/index.js

@@ -126,7 +126,13 @@ export function resolveNativeWebTools(tools) {
 export * from "./interaction.js";
 export * from "./agent-candidate.js";
 export * from "./agent-candidate-schema.js";
+export { canonicalCandidateBytes, canonicalCandidateDigest, canonicalCandidateJson, sha256Bytes, sha256DigestSchema, sha256Utf8, } from "./agent-candidate-schema-common.js";
 export * from "./agent-candidate-promotion-schema.js";
+export { agentCandidateEvaluationPolicySchema } from "./agent-improvement-measurement-schema.js";
+export * from "./agent-improvement-source.js";
+export * from "./agent-profile-improvement.js";
+export * from "./agent-profile-improvement-schema.js";
+export * from "./agent-execution-limits.js";
 export * from "./agent-profile.js";
 export * from "./certified-context.js";
 export * from "./profile-diff.js";

package/dist/interaction.d.ts

@@ -256,23 +256,6 @@ export type PermissionGrant = z.infer<typeof PermissionGrantSchema>;
 export declare function permissionAnswerSpec(opts?: {
     allowFeedback?: boolean;
 }): InteractionAnswerSpec;
-/** Shape of one legacy question (kept for the back-compat shim). */
-export type LegacyQuestion = {
-    question: string;
-    options?: Array<{
-        label: string;
-        description?: string;
-    }>;
-    multiSelect?: boolean;
-    /** When true the select field accepts write-in answers beyond `options`. */
-    allowCustom?: boolean;
-};
-/**
- * Build an answer spec from the legacy `question` event shape. Each question
- * becomes one select field (free text when it declares no options), so the old
- * question/answer path is expressible as a `question` interaction.
- */
-export declare function questionAnswerSpec(questions: LegacyQuestion[]): InteractionAnswerSpec;
 export type InteractionValidation = {
     ok: true;
 } | {

package/dist/interaction.js

@@ -176,29 +176,6 @@ export function permissionAnswerSpec(opts) {
     }
     return { fields };
 }
-/**
- * Build an answer spec from the legacy `question` event shape. Each question
- * becomes one select field (free text when it declares no options), so the old
- * question/answer path is expressible as a `question` interaction.
- */
-export function questionAnswerSpec(questions) {
-    const fields = questions.map((q, i) => {
-        const name = `q${i}`;
-        if (q.options && q.options.length > 0) {
-            return {
-                type: "select",
-                name,
-                label: q.question,
-                required: true,
-                multi: q.multiSelect === true,
-                ...(q.allowCustom === true ? { allowCustom: true } : {}),
-                options: q.options.map((o) => ({ value: o.label, label: o.label, description: o.description })),
-            };
-        }
-        return { type: "text", name, label: q.question, required: true };
-    });
-    return { fields };
-}
 /**
  * Validate an accepted answer against its spec. Used by the broker before a
  * response reaches the adapter, so malformed answers are rejected centrally.

package/dist/number-validation.d.ts

@@ -0,0 +1 @@
+export declare function numbersApproximatelyEqual(left: number, right: number): boolean;

package/dist/number-validation.js

@@ -0,0 +1,4 @@
+export function numbersApproximatelyEqual(left, right) {
+    const tolerance = Number.EPSILON * Math.max(1, Math.abs(left), Math.abs(right)) * 16;
+    return Math.abs(left - right) <= tolerance;
+}

package/dist/profile-schema.d.ts

@@ -268,13 +268,10 @@ export declare const agentProfileSchema: z.ZodObject<{
     }, z.core.$strict>>;
     harness: z.ZodOptional<z.ZodEnum<{
         "claude-code": "claude-code";
-        claude: "claude";
-        claudish: "claudish";
         nanoclaw: "nanoclaw";
         codex: "codex";
         opencode: "opencode";
         "kimi-code": "kimi-code";
-        kimi: "kimi";
         pi: "pi";
         gemini: "gemini";
         hermes: "hermes";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/agent-interface",
-  "version": "0.33.0",
+  "version": "0.35.0",
   "type": "module",
   "sideEffects": false,
   "license": "MIT",