@tangle-network/agent-app 0.43.76 → 0.44.1

package/dist/config/index.d.ts

@@ -1,6 +1,6 @@
 import { KnowledgeRequirementSpec } from '../knowledge/index.js';
 export { SatisfiedByRule } from '../knowledge/index.js';
-import { k as TangleModelConfig } from '../model-DmdkIteM.js';
+import { T as TangleModelConfig } from '../model-CdCDfBA9.js';
 import '@tangle-network/agent-eval';
 
 /**

package/dist/config/index.js

@@ -1,7 +1,126 @@
-import {
-  agentAppConfigJsonSchema,
-  defineAgentApp
-} from "../chunk-OSMNYPOG.js";
+// src/config/index.ts
+function defineAgentApp(config) {
+  return config;
+}
+var agentAppConfigJsonSchema = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://tangle.tools/schemas/agent-app-config.json",
+  title: "AgentAppConfig",
+  description: "The declarative domain surface of a Tangle agent product.",
+  type: "object",
+  additionalProperties: false,
+  required: ["identity", "taxonomy", "knowledge", "integrations"],
+  properties: {
+    identity: {
+      type: "object",
+      additionalProperties: false,
+      required: ["name", "persona"],
+      properties: {
+        name: { type: "string", description: "Product/agent name." },
+        persona: { type: "string", description: "One-paragraph persona \u2014 the system-prompt spine." },
+        systemPromptFragments: {
+          type: "array",
+          items: { type: "string" },
+          description: "Verbatim system-prompt fragments appended after the persona, in order."
+        },
+        disclaimers: {
+          type: "object",
+          additionalProperties: { type: "string" },
+          description: "Named disclaimers keyed by stable id; values are literal text."
+        }
+      }
+    },
+    taxonomy: {
+      type: "object",
+      additionalProperties: false,
+      required: ["proposalTypes", "regulatedTypes"],
+      properties: {
+        proposalTypes: {
+          type: "array",
+          items: { type: "string" },
+          description: "Closed allow-list of proposal types the product can emit."
+        },
+        regulatedTypes: {
+          type: "array",
+          items: { type: "string" },
+          description: "Subset of proposalTypes that is approval-gated (certified-human required)."
+        }
+      }
+    },
+    knowledge: {
+      type: "object",
+      additionalProperties: false,
+      required: ["sources", "requirements"],
+      properties: {
+        sources: {
+          type: "array",
+          description: "Sources the acquisition loop may draw on.",
+          items: {
+            type: "object",
+            additionalProperties: false,
+            required: ["uri"],
+            properties: {
+              uri: { type: "string", description: "Where the source lives (opaque to agent-app)." },
+              kind: { type: "string", description: "Optional source classifier (web/vault/regulation/\u2026)." }
+            }
+          }
+        },
+        requirements: {
+          type: "array",
+          description: "Declarative KnowledgeRequirementSpec[] (../knowledge) that gate the loop.",
+          items: { type: "object", additionalProperties: true }
+        },
+        loop: {
+          type: "object",
+          additionalProperties: false,
+          description: "Acquisition-loop config.",
+          properties: {
+            goal: { type: "string", description: "Acquisition goal in natural language." },
+            minConfidence: {
+              type: "number",
+              minimum: 0,
+              maximum: 1,
+              description: "Minimum aggregate confidence the loop must reach."
+            },
+            freshness: { type: "string", description: "How fresh acquired knowledge must be." }
+          }
+        }
+      }
+    },
+    integrations: {
+      type: "object",
+      additionalProperties: false,
+      required: ["enabled"],
+      properties: {
+        enabled: {
+          type: "array",
+          items: { type: "string" },
+          description: "Enabled agent-integrations catalog kinds."
+        }
+      }
+    },
+    ui: {
+      type: "object",
+      additionalProperties: false,
+      description: "UI capability flags.",
+      properties: {
+        generatedUi: { type: "boolean", description: "Whether the agent may emit generated UI." }
+      }
+    },
+    model: {
+      type: "object",
+      additionalProperties: false,
+      description: "Resolved TangleModelConfig (../runtime). Omit to resolve from env.",
+      required: ["provider", "model", "apiKey", "baseUrl"],
+      properties: {
+        provider: { type: "string", enum: ["openai-compat", "anthropic"] },
+        model: { type: "string" },
+        apiKey: { type: "string" },
+        baseUrl: { type: "string" }
+      }
+    }
+  }
+};
 export {
   agentAppConfigJsonSchema,
   defineAgentApp

package/dist/config/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}
+{"version":3,"sources":["../../src/config/index.ts"],"sourcesContent":["/**\n * `@tangle-network/agent-app/config` — the typed `AgentAppConfig` contract.\n *\n * This is the single declarative DATA surface a coding agent fills to stand up a\n * new agent product. Everything an agent product otherwise hand-rolls as\n * imperative wiring — who the agent is, which proposal types exist and which are\n * approval-gated, what knowledge the control loop requires, which integrations\n * are connectable, how the model resolves — is expressed here as plain data the\n * rest of agent-app's modules consume through their typed seams:\n *\n *  - `identity`     → the system-prompt + disclaimer surface the chat pipeline reads.\n *  - `taxonomy`     → which `submit_proposal` types the `./tools` side channel\n *                     accepts, and which the approval queue treats as regulated\n *                     (certified-human-gated).\n *  - `knowledge`    → the `./knowledge` requirement specs that gate the loop, plus\n *                     the acquisition-loop goal/threshold the researcher pursues.\n *  - `integrations` → which `@tangle-network/agent-integrations` catalog kinds the\n *                     product enables.\n *  - `ui`           → whether the agent may emit generated UI (`render_ui`).\n *  - `model`        → the `./runtime` `TangleModelConfig` (or null to resolve from env).\n *\n * Layering: this module is the CONTRACT only — pure types + an identity helper.\n * It introduces no behavior and no engine dependency; it REUSES the existing\n * `KnowledgeRequirementSpec`/`SatisfiedByRule` (from `../knowledge`) and\n * `TangleModelConfig` (from `../runtime`) rather than redefining them, so the\n * config a product authors is the exact shape those modules already consume.\n * Steps that build the composer/loader read this file as the schema floor.\n */\n\nimport type {\n  KnowledgeRequirementSpec,\n  SatisfiedByRule,\n} from '../knowledge/index'\nimport type { TangleModelConfig } from '../runtime/index'\n\n// Re-export the borrowed types so a config author has a single import surface\n// (`@tangle-network/agent-app/config`) and never has to reach into `../knowledge`\n// or `../runtime` to spell out a field's type. These are the SAME types the\n// knowledge gate and runtime model resolver consume — not parallel copies.\nexport type { KnowledgeRequirementSpec, SatisfiedByRule, TangleModelConfig }\n\n/**\n * Who the agent is, as data. Composed into the chat pipeline's system prompt;\n * never baked into agent-app (a domain value, per the layering contract).\n */\nexport interface AgentIdentityConfig {\n  /** Product/agent name, e.g. `\"Acme Support Copilot\"`. Shown to the user and\n   *  available to the system-prompt builder. */\n  name: string\n  /** One-paragraph persona statement — the agent's role, voice, and remit. The\n   *  spine of the system prompt. */\n  persona: string\n  /** Additional system-prompt fragments appended verbatim after the persona\n   *  (standing workflows, hard rules, tone). Order is preserved. Optional. */\n  systemPromptFragments?: string[]\n  /** Named disclaimers the product surfaces (e.g. a regulatory human-in-the-loop\n   *  notice). Keyed by a stable id (`compliance`, `not-advice`, …) so the chat\n   *  pipeline / UI can select one by name. Values are the literal text. Optional. */\n  disclaimers?: Record<string, string>\n}\n\n/**\n * The proposal taxonomy, as data. `proposalTypes` is the closed set of\n * `submit_proposal` types the `./tools` side channel accepts; `regulatedTypes`\n * is the subset that is approval-gated — the executor refuses to run one without\n * a certified human approver. `regulatedTypes` MUST be a subset of\n * `proposalTypes` (validated by the loader step; not enforced at the type level).\n */\nexport interface AgentTaxonomyConfig {\n  /** Every proposal type this product can emit, e.g.\n   *  `['recommend', 'contact', 'escalate']`. The closed allow-list\n   *  the tool layer validates a `submit_proposal` call against. */\n  proposalTypes: string[]\n  /** The subset of `proposalTypes` that is regulated → cannot execute without a\n   *  certified-human approver. The approval executor reads this to decide which\n   *  proposals are fail-loud certified-gated. */\n  regulatedTypes: string[]\n}\n\n/** A knowledge source the acquisition loop / researcher may draw on. */\nexport interface KnowledgeSourceSpec {\n  /** Where the source lives — a URL, a `vault://` path, an integration ref, etc.\n   *  Opaque to agent-app; the consumer's loader resolves it. */\n  uri: string\n  /** Optional source classifier the researcher uses to pick a fetch strategy,\n   *  e.g. `'web'`, `'vault'`, `'regulation'`, `'integration'`. Free-form. */\n  kind?: string\n}\n\n/**\n * The knowledge-acquisition loop config — the goal the researcher pursues and\n * the gate it must clear before the loop is considered satisfied. All optional;\n * a product with only static requirement specs omits it.\n */\nexport interface KnowledgeLoopConfig {\n  /** The acquisition goal in natural language, e.g.\n   *  `\"ground every quoted premium against a real policy record\"`. */\n  goal?: string\n  /** The minimum aggregate confidence [0, 1] the loop must reach to pass its\n   *  gate. The runtime control loop blocks below this. Default decided by the\n   *  consumer's loop wiring when omitted. */\n  minConfidence?: number\n  /** How fresh acquired knowledge must be, e.g. `'static'`, `'7d'`, `'session'`.\n   *  Free-form; the consumer's loop interprets it. */\n  freshness?: string\n}\n\n/**\n * The knowledge surface, as data. `sources` are what the researcher may read;\n * `requirements` are the declarative `./knowledge` specs that gate the control\n * loop (reused verbatim — the same `KnowledgeRequirementSpec` the gate scores);\n * `loop` configures the acquisition pass.\n */\nexport interface AgentKnowledgeConfig {\n  /** Sources the acquisition loop / researcher may draw on. */\n  sources: KnowledgeSourceSpec[]\n  /** The declarative requirement specs that gate the loop. Reuses\n   *  `KnowledgeRequirementSpec` from `../knowledge` — `buildKnowledgeRequirements`\n   *  + `deriveSignals` consume these directly. */\n  requirements: KnowledgeRequirementSpec[]\n  /** Optional acquisition-loop config (goal + confidence gate + freshness). */\n  loop?: KnowledgeLoopConfig\n}\n\n/**\n * Which integrations the product enables, as data. `enabled` lists\n * `@tangle-network/agent-integrations` catalog kinds the product connects\n * (e.g. `['salesforce', 'gmail', 'whatsapp']`); the integration hub resolves\n * each to a connector. Strings, not connector objects — agent-app bakes no\n * catalog value.\n */\nexport interface AgentIntegrationsConfig {\n  /** Catalog kinds this product enables. */\n  enabled: string[]\n}\n\n/** UI capability flags, as data. */\nexport interface AgentUiConfig {\n  /** Whether the agent may emit generated UI (the `render_ui` / OpenUI side\n   *  channel). When false/omitted, the tool layer can omit/refuse the tool.\n   *  Default behavior decided by the consumer; omit to leave unset. */\n  generatedUi?: boolean\n}\n\n/**\n * The declarative domain surface of a Tangle agent product.\n *\n * A coding agent fills THIS object and nothing else to define a product's\n * identity, proposal taxonomy, knowledge gate, integrations, UI capability, and\n * model. Every field is DATA consumed by an agent-app module through its typed\n * seam — no field is behavior. Author it through {@link defineAgentApp} for\n * autocomplete and a single import.\n */\nexport interface AgentAppConfig {\n  /** Who the agent is — name, persona, system-prompt fragments, disclaimers. */\n  identity: AgentIdentityConfig\n  /** Proposal types + which are regulated/approval-gated. */\n  taxonomy: AgentTaxonomyConfig\n  /** Knowledge sources, requirement specs (the loop gate), and loop config. */\n  knowledge: AgentKnowledgeConfig\n  /** Enabled integration catalog kinds. */\n  integrations: AgentIntegrationsConfig\n  /** UI capability flags. Optional. */\n  ui?: AgentUiConfig\n  /** The resolved model config (`../runtime`'s `TangleModelConfig`). Omit to\n   *  resolve from env at boot via `resolveTangleModelConfig`. */\n  model?: TangleModelConfig\n}\n\n/**\n * Identity helper: returns its argument unchanged, but anchors inference so a\n * coding agent authoring a config gets full autocomplete + type-checking from a\n * single import. The canonical way to declare a product config:\n *\n * ```ts\n * import { defineAgentApp } from '@tangle-network/agent-app/config'\n *\n * export const config = defineAgentApp({\n *   identity: { name: 'Acme Ops', persona: '…' },\n *   taxonomy: { proposalTypes: ['recommend', 'contact'], regulatedTypes: ['recommend'] },\n *   knowledge: { sources: [], requirements: [] },\n *   integrations: { enabled: ['salesforce'] },\n * })\n * ```\n */\nexport function defineAgentApp<const T extends AgentAppConfig>(config: T): T {\n  return config\n}\n\n/**\n * Machine-readable JSON Schema (draft 2020-12) for {@link AgentAppConfig}.\n *\n * The schema FLOOR a non-TypeScript coding agent (or a config validator/UI) reads\n * to know the shape without parsing the `.d.ts`. Kept in lockstep with the\n * interfaces above by the config test, which asserts the documented fields are\n * present. `KnowledgeRequirementSpec`'s full sub-shape is intentionally left\n * `additionalProperties: true` here — its authoritative definition lives in\n * `../knowledge`; this floor pins only the fields the config contract owns.\n */\nexport const agentAppConfigJsonSchema = {\n  $schema: 'https://json-schema.org/draft/2020-12/schema',\n  $id: 'https://tangle.tools/schemas/agent-app-config.json',\n  title: 'AgentAppConfig',\n  description: 'The declarative domain surface of a Tangle agent product.',\n  type: 'object',\n  additionalProperties: false,\n  required: ['identity', 'taxonomy', 'knowledge', 'integrations'],\n  properties: {\n    identity: {\n      type: 'object',\n      additionalProperties: false,\n      required: ['name', 'persona'],\n      properties: {\n        name: { type: 'string', description: 'Product/agent name.' },\n        persona: { type: 'string', description: 'One-paragraph persona — the system-prompt spine.' },\n        systemPromptFragments: {\n          type: 'array',\n          items: { type: 'string' },\n          description: 'Verbatim system-prompt fragments appended after the persona, in order.',\n        },\n        disclaimers: {\n          type: 'object',\n          additionalProperties: { type: 'string' },\n          description: 'Named disclaimers keyed by stable id; values are literal text.',\n        },\n      },\n    },\n    taxonomy: {\n      type: 'object',\n      additionalProperties: false,\n      required: ['proposalTypes', 'regulatedTypes'],\n      properties: {\n        proposalTypes: {\n          type: 'array',\n          items: { type: 'string' },\n          description: 'Closed allow-list of proposal types the product can emit.',\n        },\n        regulatedTypes: {\n          type: 'array',\n          items: { type: 'string' },\n          description: 'Subset of proposalTypes that is approval-gated (certified-human required).',\n        },\n      },\n    },\n    knowledge: {\n      type: 'object',\n      additionalProperties: false,\n      required: ['sources', 'requirements'],\n      properties: {\n        sources: {\n          type: 'array',\n          description: 'Sources the acquisition loop may draw on.',\n          items: {\n            type: 'object',\n            additionalProperties: false,\n            required: ['uri'],\n            properties: {\n              uri: { type: 'string', description: 'Where the source lives (opaque to agent-app).' },\n              kind: { type: 'string', description: 'Optional source classifier (web/vault/regulation/…).' },\n            },\n          },\n        },\n        requirements: {\n          type: 'array',\n          description: \"Declarative KnowledgeRequirementSpec[] (../knowledge) that gate the loop.\",\n          items: { type: 'object', additionalProperties: true },\n        },\n        loop: {\n          type: 'object',\n          additionalProperties: false,\n          description: 'Acquisition-loop config.',\n          properties: {\n            goal: { type: 'string', description: 'Acquisition goal in natural language.' },\n            minConfidence: {\n              type: 'number',\n              minimum: 0,\n              maximum: 1,\n              description: 'Minimum aggregate confidence the loop must reach.',\n            },\n            freshness: { type: 'string', description: 'How fresh acquired knowledge must be.' },\n          },\n        },\n      },\n    },\n    integrations: {\n      type: 'object',\n      additionalProperties: false,\n      required: ['enabled'],\n      properties: {\n        enabled: {\n          type: 'array',\n          items: { type: 'string' },\n          description: 'Enabled agent-integrations catalog kinds.',\n        },\n      },\n    },\n    ui: {\n      type: 'object',\n      additionalProperties: false,\n      description: 'UI capability flags.',\n      properties: {\n        generatedUi: { type: 'boolean', description: 'Whether the agent may emit generated UI.' },\n      },\n    },\n    model: {\n      type: 'object',\n      additionalProperties: false,\n      description: \"Resolved TangleModelConfig (../runtime). Omit to resolve from env.\",\n      required: ['provider', 'model', 'apiKey', 'baseUrl'],\n      properties: {\n        provider: { type: 'string', enum: ['openai-compat', 'anthropic'] },\n        model: { type: 'string' },\n        apiKey: { type: 'string' },\n        baseUrl: { type: 'string' },\n      },\n    },\n  },\n} as const\n"],"mappings":"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","names":[]}

package/dist/{contract-B3h7peV3.d.ts → contract-CEewO6DI.d.ts}

@@ -182,4 +182,4 @@ declare function stampInteractionAnswers(parts: Array<Record<string, unknown>>,
  *  Returns null (caller logs) when the part is not one of ours. */
 declare function persistedPartToInteraction(part: Record<string, unknown>): ChatInteraction | null;
 
-export { noticePart as A, noticePartKey as B, type ChatFreeTextField as C, parseInteractionAnswers as D, parseInteractionCancel as E, parseInteractionRequest as F, persistedPartToInteraction as G, questionInteractionContentSignature as H, INTERACTION_CANCEL_EVENT as I, stampInteractionAnswers as J, type NoticeKind as N, type ParseInteractionAnswersResult as P, type ChatInteraction as a, type ChatInteractionField as b, type ChatInteractionStatus as c, type ChatSelectField as d, type ComposerAnswerDelivery as e, INTERACTION_EVENT as f, INTERACTION_RESOLVED_EVENT as g, type InteractionAnswerValue as h, type InteractionAnswers as i, type InteractionCancelData as j, type InteractionPersistedPart as k, type InteractionRequestWire as l, type NoticePersistedPart as m, type ParseInteractionResult as n, canTransitionInteractionStatus as o, cancelStatusFor as p, composerAnswerData as q, composerAnswerDeliveries as r, dedupeQuestionInteractionsByContent as s, fieldAcceptsFreeText as t, interactionFromWireRequest as u, interactionPartKey as v, interactionToPersistedPart as w, isRenderableInteractionKind as x, isSafeInteractionFieldKey as y, isTerminalInteractionStatus as z };
+export { noticePart as A, noticePartKey as B, type ChatInteractionStatus as C, parseInteractionAnswers as D, parseInteractionCancel as E, parseInteractionRequest as F, persistedPartToInteraction as G, questionInteractionContentSignature as H, type InteractionAnswers as I, stampInteractionAnswers as J, type NoticeKind as N, type ParseInteractionAnswersResult as P, type ChatInteractionField as a, type ChatInteraction as b, type InteractionCancelData as c, type ChatSelectField as d, type InteractionRequestWire as e, type ChatFreeTextField as f, type ComposerAnswerDelivery as g, INTERACTION_CANCEL_EVENT as h, INTERACTION_EVENT as i, INTERACTION_RESOLVED_EVENT as j, type InteractionAnswerValue as k, type InteractionPersistedPart as l, type NoticePersistedPart as m, type ParseInteractionResult as n, canTransitionInteractionStatus as o, cancelStatusFor as p, composerAnswerData as q, composerAnswerDeliveries as r, dedupeQuestionInteractionsByContent as s, fieldAcceptsFreeText as t, interactionFromWireRequest as u, interactionPartKey as v, interactionToPersistedPart as w, isRenderableInteractionKind as x, isSafeInteractionFieldKey as y, isTerminalInteractionStatus as z };

package/dist/design-canvas/index.d.ts

@@ -5,10 +5,10 @@ export { A as AddElementOperation, b as AddPageOperation, c as ApplyDataOperatio
 import { a as SceneStore, N as NewSceneDecision, b as SceneDocumentRecord } from '../store-CqfDtnPQ.js';
 export { c as SceneDecision, d as SceneExportFormat, e as SceneExportRecord, S as SceneStoreScope } from '../store-CqfDtnPQ.js';
 export { C as CHANNEL_PRESETS, a as ChannelPreset, b as ChannelPresetId, c as ChannelScaleResult, E as EXPORT_PRESETS, d as ExportCropRect, e as ExportFormat, f as ExportPreset, S as SIZE_PRESETS, g as SizePreset, h as bleedAwareExportBounds, i as bleedAwareExportRect, j as findPreset, m as matchPreset, r as requireChannelPreset, s as scaleForPreset, k as scalePageForChannelPreset } from '../export-presets-mgVulRaV.js';
-import { c as McpToolDefinition } from '../mcp-rpc-BfUOsalw.js';
-import { S as ScopedMcpServerEntryOptions, A as AppToolMcpServer } from '../mcp-BjPqQ-3C.js';
-import '../types-CBRyqijY.js';
-import '../auth-_FU8w01b.js';
+import { a as McpToolDefinition } from '../mcp-rpc-CzU5LWWT.js';
+import { S as ScopedMcpServerEntryOptions, A as AppToolMcpServer } from '../mcp-D3qVzbE1.js';
+import '../types-BCxK0wyS.js';
+import '../auth-anc7mv2W.js';
 
 /**
  * Pre-write validation for scene operations. Every rule runs against a

package/dist/design-canvas-react/index.js

@@ -12,7 +12,7 @@ import {
   downloadDataUrl,
   exportDocumentJson,
   exportPageDataUrl
-} from "../chunk-E7N67FYI.js";
+} from "../chunk-Q3FONVAK.js";
 import {
   BTN,
   BTN_ACTIVE,
@@ -41,7 +41,8 @@ import {
   buildRulerTicks,
   formatRulerLabel,
   selectTickStep
-} from "../chunk-22GLESKE.js";
+} from "../chunk-O63WWYET.js";
+import "../chunk-TZO3SOUL.js";
 import "../chunk-ZN5J47UX.js";
 import {
   DEFAULT_INSERT_TEMPLATES,
@@ -82,16 +83,15 @@ import {
   setPagePropsCommand,
   ungroupElementCommand
 } from "../chunk-VTWKH4YU.js";
+import {
+  DesignCanvasChromeLazy,
+  DesignCanvasLazy
+} from "../chunk-4TI7QWLW.js";
 import {
   assertSceneMediaSrc,
   bleedAwareExportBounds,
   scaleForPreset
 } from "../chunk-VWOPOLVO.js";
-import {
-  DesignCanvasChromeLazy,
-  DesignCanvasLazy
-} from "../chunk-ROLFDOMJ.js";
-import "../chunk-TZO3SOUL.js";
 import "../chunk-PTUMBMVH.js";
 
 // src/design-canvas-react/components/CanvasInsertPanel.tsx

package/dist/design-canvas-react/lazy.js

@@ -1,7 +1,7 @@
 import {
   DesignCanvasChromeLazy,
   DesignCanvasLazy
-} from "../chunk-ROLFDOMJ.js";
+} from "../chunk-4TI7QWLW.js";
 export {
   DesignCanvasChromeLazy,
   DesignCanvasLazy

package/dist/eval/index.d.ts

@@ -1,6 +1,6 @@
 import { CompletionRequirement, RuntimeEventLike } from '@tangle-network/agent-eval';
 export { CompletionRequirement, CompletionVerdict, CorrectnessChecker, ProducedState, RuntimeEventLike, SatisfiedBy, TaskGold, createLlmCorrectnessChecker, extractProducedState, verifyCompletion, weightedComposite } from '@tangle-network/agent-eval';
-import { h as AppToolProducedEvent } from '../types-CBRyqijY.js';
+import { A as AppToolProducedEvent } from '../types-BCxK0wyS.js';
 
 /**
  * Eval — the app-shell BRIDGE to `@tangle-network/agent-eval`, not a reimpl.

package/dist/eval/index.js

@@ -1,11 +1,25 @@
-import {
-  createLlmCorrectnessChecker,
-  createTokenRecallChecker,
-  extractProducedState,
-  producedFromToolEvents,
-  verifyCompletion,
-  weightedComposite
-} from "../chunk-FA4XR66Y.js";
+// src/eval/index.ts
+import { verifyCompletion, extractProducedState, weightedComposite, createLlmCorrectnessChecker } from "@tangle-network/agent-eval";
+function producedFromToolEvents(events) {
+  return events.map(
+    (e) => e.type === "proposal_created" ? { type: "proposal_created", proposalId: e.proposalId, title: e.title, status: e.status, content: e.content } : { type: "artifact", artifactId: `vault:${e.path}`, name: e.path, uri: `vault://${e.path}`, mimeType: "text/markdown", content: e.content }
+  );
+}
+var STOPWORDS = /* @__PURE__ */ new Set(["the", "a", "an", "and", "or", "for", "to", "of", "in", "on", "with", "review", "update", "new", "proposed"]);
+function createTokenRecallChecker(opts = {}) {
+  const minRecall = opts.minRecall ?? 0.5;
+  const minLen = opts.minContentLength ?? 120;
+  return async (requirement, content) => {
+    const body = content.trim();
+    if (body.length < minLen) return { correct: false, reason: `content too thin (${body.length} chars) to be the deliverable` };
+    const tokens = requirement.title.toLowerCase().split(/[^a-z0-9]+/).filter((t) => t.length > 2 && !STOPWORDS.has(t));
+    if (tokens.length === 0) return { correct: true, reason: "requirement title has no significant tokens \u2014 structural match accepted" };
+    const lower = body.toLowerCase();
+    const hits = tokens.filter((t) => lower.includes(t)).length;
+    const recall = hits / tokens.length;
+    return recall >= minRecall ? { correct: true, reason: `content recalls ${hits}/${tokens.length} requirement tokens` } : { correct: false, reason: `content recalls only ${hits}/${tokens.length} requirement tokens` };
+  };
+}
 export {
   createLlmCorrectnessChecker,
   createTokenRecallChecker,

package/dist/eval/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}
+{"version":3,"sources":["../../src/eval/index.ts"],"sourcesContent":["/**\n * Eval — the app-shell BRIDGE to `@tangle-network/agent-eval`, not a reimpl.\n *\n * The completion/scoring ENGINE lives in agent-eval (a peer dependency):\n * `verifyCompletion`, `extractProducedState`, `weightedComposite`,\n * `createLlmCorrectnessChecker`, and the `CompletionRequirement` / `TaskGold` /\n * `ProducedState` types — all re-exported here so a consumer has one import\n * root. This module adds only what agent-eval doesn't have and what is\n * app-shell-specific:\n *\n *   1. {@link producedFromToolEvents} — the bridge: turn the structured app-tool\n *      side channel's `AppToolProducedEvent`s (from a tool runtime executor's\n *      `onProduced`) into the `RuntimeEventLike`s agent-eval's\n *      `extractProducedState` consumes. This is the one piece that knows about\n *      the app-tool channel, so it belongs here, not in the engine.\n *   2. {@link createTokenRecallChecker} — a deterministic, no-LLM\n *      `CorrectnessChecker` (agent-eval ships only the LLM one). For apps/tests\n *      that gate completion without a judge call.\n *\n * Full campaigns (persona simulation, traces, scorecards, held-out gates) are\n * agent-eval's `runEvalCampaign` / `AgentDriver` / `BenchmarkRunner` — use them\n * directly; this module composes with them.\n */\nimport type { RuntimeEventLike, CompletionRequirement } from '@tangle-network/agent-eval'\nimport type { AppToolProducedEvent } from '../tools/types'\n\n// Re-export the engine so consumers import completion + scoring from one place.\nexport { verifyCompletion, extractProducedState, weightedComposite, createLlmCorrectnessChecker } from '@tangle-network/agent-eval'\nexport type {\n  CompletionRequirement,\n  TaskGold,\n  ProducedState,\n  SatisfiedBy,\n  CompletionVerdict,\n  CorrectnessChecker,\n  RuntimeEventLike,\n} from '@tangle-network/agent-eval'\n\n/**\n * Bridge the app-tool side channel's produced events into the runtime-event\n * shape agent-eval's `extractProducedState` reads. Pipe it:\n *   `verifyCompletion(taskGold, extractProducedState(producedFromToolEvents(events)), checker)`\n */\nexport function producedFromToolEvents(events: readonly AppToolProducedEvent[]): RuntimeEventLike[] {\n  return events.map((e) =>\n    e.type === 'proposal_created'\n      ? { type: 'proposal_created', proposalId: e.proposalId, title: e.title, status: e.status, content: e.content }\n      : { type: 'artifact', artifactId: `vault:${e.path}`, name: e.path, uri: `vault://${e.path}`, mimeType: 'text/markdown', content: e.content },\n  )\n}\n\nconst STOPWORDS = new Set(['the', 'a', 'an', 'and', 'or', 'for', 'to', 'of', 'in', 'on', 'with', 'review', 'update', 'new', 'proposed'])\n\n/**\n * A deterministic `CorrectnessChecker` (agent-eval exports only\n * `createLlmCorrectnessChecker`). A produced item fulfils a requirement when\n * its content is substantive and recalls ≥ `minRecall` of the requirement\n * title's significant tokens. No network — the default gate for apps/tests\n * without an LLM judge. Pass to `verifyCompletion` as the checker.\n */\nexport function createTokenRecallChecker(opts: { minRecall?: number; minContentLength?: number } = {}): (\n  requirement: CompletionRequirement,\n  content: string,\n) => Promise<{ correct: boolean; reason: string }> {\n  const minRecall = opts.minRecall ?? 0.5\n  const minLen = opts.minContentLength ?? 120\n  return async (requirement, content) => {\n    const body = content.trim()\n    if (body.length < minLen) return { correct: false, reason: `content too thin (${body.length} chars) to be the deliverable` }\n    const tokens = requirement.title.toLowerCase().split(/[^a-z0-9]+/).filter((t) => t.length > 2 && !STOPWORDS.has(t))\n    if (tokens.length === 0) return { correct: true, reason: 'requirement title has no significant tokens — structural match accepted' }\n    const lower = body.toLowerCase()\n    const hits = tokens.filter((t) => lower.includes(t)).length\n    const recall = hits / tokens.length\n    return recall >= minRecall\n      ? { correct: true, reason: `content recalls ${hits}/${tokens.length} requirement tokens` }\n      : { correct: false, reason: `content recalls only ${hits}/${tokens.length} requirement tokens` }\n  }\n}\n"],"mappings":";AA2BA,SAAS,kBAAkB,sBAAsB,mBAAmB,mCAAmC;AAgBhG,SAAS,uBAAuB,QAA6D;AAClG,SAAO,OAAO;AAAA,IAAI,CAAC,MACjB,EAAE,SAAS,qBACP,EAAE,MAAM,oBAAoB,YAAY,EAAE,YAAY,OAAO,EAAE,OAAO,QAAQ,EAAE,QAAQ,SAAS,EAAE,QAAQ,IAC3G,EAAE,MAAM,YAAY,YAAY,SAAS,EAAE,IAAI,IAAI,MAAM,EAAE,MAAM,KAAK,WAAW,EAAE,IAAI,IAAI,UAAU,iBAAiB,SAAS,EAAE,QAAQ;AAAA,EAC/I;AACF;AAEA,IAAM,YAAY,oBAAI,IAAI,CAAC,OAAO,KAAK,MAAM,OAAO,MAAM,OAAO,MAAM,MAAM,MAAM,MAAM,QAAQ,UAAU,UAAU,OAAO,UAAU,CAAC;AAShI,SAAS,yBAAyB,OAA0D,CAAC,GAGjD;AACjD,QAAM,YAAY,KAAK,aAAa;AACpC,QAAM,SAAS,KAAK,oBAAoB;AACxC,SAAO,OAAO,aAAa,YAAY;AACrC,UAAM,OAAO,QAAQ,KAAK;AAC1B,QAAI,KAAK,SAAS,OAAQ,QAAO,EAAE,SAAS,OAAO,QAAQ,qBAAqB,KAAK,MAAM,gCAAgC;AAC3H,UAAM,SAAS,YAAY,MAAM,YAAY,EAAE,MAAM,YAAY,EAAE,OAAO,CAAC,MAAM,EAAE,SAAS,KAAK,CAAC,UAAU,IAAI,CAAC,CAAC;AAClH,QAAI,OAAO,WAAW,EAAG,QAAO,EAAE,SAAS,MAAM,QAAQ,+EAA0E;AACnI,UAAM,QAAQ,KAAK,YAAY;AAC/B,UAAM,OAAO,OAAO,OAAO,CAAC,MAAM,MAAM,SAAS,CAAC,CAAC,EAAE;AACrD,UAAM,SAAS,OAAO,OAAO;AAC7B,WAAO,UAAU,YACb,EAAE,SAAS,MAAM,QAAQ,mBAAmB,IAAI,IAAI,OAAO,MAAM,sBAAsB,IACvF,EAAE,SAAS,OAAO,QAAQ,wBAAwB,IAAI,IAAI,OAAO,MAAM,sBAAsB;AAAA,EACnG;AACF;","names":[]}

package/dist/{flow-types-CqomVAUN.d.ts → flow-types-CJxEmaRy.d.ts}

@@ -23,4 +23,4 @@ interface FlowTrace {
     toolCalls: number;
 }
 
-export type { FlowSpan as F, FlowTrace as a };
+export type { FlowTrace as F, FlowSpan as a };

package/dist/integrations/index.js

@@ -1,8 +1,70 @@
-import {
-  HubExecClient,
-  invokeIntegrationHub,
-  resolveIntegrationAction
-} from "../chunk-5TESA4SN.js";
+// src/integrations/index.ts
+import { parseIntegrationToolName } from "@tangle-network/agent-integrations/catalog";
+function resolveIntegrationAction(toolName) {
+  let parsed;
+  try {
+    parsed = parseIntegrationToolName(toolName);
+  } catch {
+    return void 0;
+  }
+  if (!parsed.providerId || !parsed.connectorId || !parsed.actionId) return void 0;
+  return { ...parsed, path: `${parsed.providerId}.${parsed.connectorId}.${parsed.actionId}` };
+}
+var HubExecClient = class {
+  baseUrl;
+  bearer;
+  fetchImpl;
+  constructor(options) {
+    if (!options.baseUrl) throw new Error("HubExecClient: baseUrl is required");
+    if (!options.bearer) throw new Error("HubExecClient: bearer is required");
+    this.baseUrl = options.baseUrl.replace(/\/+$/, "");
+    this.bearer = options.bearer;
+    this.fetchImpl = options.fetchImpl ?? fetch;
+  }
+  async exec(input) {
+    const response = await this.fetchImpl(`${this.baseUrl}/v1/hub/exec`, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${this.bearer}`, "Content-Type": "application/json", Accept: "application/json" },
+      body: JSON.stringify({ path: input.path, input: input.actionInput, connectionId: input.connectionId })
+    });
+    const envelope = await this.readEnvelope(response);
+    if (response.ok && envelope.success) return { succeeded: true, result: envelope.data?.result };
+    return {
+      succeeded: false,
+      code: envelope.error?.code ?? `HUB_HTTP_${response.status}`,
+      message: envelope.error?.message ?? `Hub /exec returned ${response.status}`,
+      approval: envelope.error?.details?.approval
+    };
+  }
+  async readEnvelope(response) {
+    const text = await response.text();
+    if (!text) return { success: false, error: { code: `HUB_HTTP_${response.status}`, message: `Hub returned ${response.status} with no body` } };
+    try {
+      return JSON.parse(text);
+    } catch {
+      return { success: false, error: { code: "HUB_BAD_RESPONSE", message: `Hub returned non-JSON (${response.status}): ${text.slice(0, 200)}` } };
+    }
+  }
+};
+async function invokeIntegrationHub(input, deps) {
+  const env = deps.env ?? process.env;
+  const baseUrl = deps.baseUrl ?? env.TANGLE_PLATFORM_URL?.trim();
+  if (!baseUrl) return { status: 500, body: { error: "TANGLE_PLATFORM_URL is not configured" } };
+  const action = resolveIntegrationAction(input.toolName);
+  if (!action) return { status: 400, body: { error: `Unsupported integration tool: ${input.toolName}` } };
+  const bearer = await deps.apiKeyResolver(input.userId);
+  if (!bearer) return { status: 401, body: { error: "Tangle account not linked \u2014 connect integrations from the app first" } };
+  const client = new HubExecClient({ baseUrl, bearer, fetchImpl: deps.fetchImpl });
+  const outcome = await client.exec({ path: action.path, actionInput: input.args ?? {} });
+  if (outcome.succeeded) {
+    return { status: 200, body: { success: true, path: action.path, providerId: action.providerId, action: action.actionId, result: outcome.result } };
+  }
+  const status = outcome.code === "HUB_APPROVAL_REQUIRED" ? 409 : 502;
+  return {
+    status,
+    body: { success: false, path: action.path, code: outcome.code, error: outcome.message, ...outcome.approval ? { approval: outcome.approval } : {} }
+  };
+}
 export {
   HubExecClient,
   invokeIntegrationHub,

package/dist/integrations/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}
+{"version":3,"sources":["../../src/integrations/index.ts"],"sourcesContent":["/**\n * Integration-hub WIRING — the agent→hub invocation path every Tangle agent app\n * forks. The integration ENGINE (catalog, connectors, OAuth, policy) is\n * `@tangle-network/agent-integrations` (a peer dependency); this module is the\n * thin app-side wiring on top: a typed client over the platform hub's\n * `POST /v1/hub/exec`, MCP-tool-name → hub-action-path resolution, and the\n * per-turn invoke flow the `integration_invoke` tool calls.\n *\n * The product supplies its own catalog (which connectors it uses) and its own\n * per-user api-key resolver (the `apiKeyResolver` seam) — this module owns\n * neither credentials nor the action catalog.\n */\nimport { parseIntegrationToolName } from '@tangle-network/agent-integrations/catalog'\n\n/** `{ success: false }` codes the hub returns on `/exec`. */\nexport type HubExecErrorCode =\n  | 'HUB_APPROVAL_REQUIRED'\n  | 'HUB_POLICY_DENIED'\n  | 'HUB_CONNECTION_MISSING'\n  | 'HUB_CONNECTION_REVOKED'\n  | 'HUB_CONFIG_MISSING'\n  | 'HUB_NOT_FOUND'\n  | string\n\n/** Outcome of a hub `/exec` call. Callers MUST inspect `succeeded` before\n *  reading `result` — a denied or approval-gated write resolves with\n *  `succeeded: false` and a populated `code`, never a thrown silent failure. */\nexport type HubExecResult =\n  | { succeeded: true; result: unknown }\n  | { succeeded: false; code: HubExecErrorCode; message: string; approval?: unknown }\n\n/** Define configuration options for initializing a Hub execution client */\nexport interface HubExecClientOptions {\n  /** Platform base URL (e.g. `TANGLE_PLATFORM_URL`). */\n  baseUrl: string\n  /** Calling user's Tangle API key — the hub principal bearer. */\n  bearer: string\n  /** Test seam. Defaults to global `fetch`. */\n  fetchImpl?: typeof fetch\n}\n\n/** The provider/connector/action a hub action path addresses, plus the dotted\n *  `path` the hub `/exec` endpoint expects. */\nexport interface ParsedIntegrationAction {\n  providerId: string\n  connectorId: string\n  actionId: string\n  /** `provider.connector.action`. */\n  path: string\n}\n\n/**\n * Resolve an MCP tool name (the opaque `int_…` catalog name the agent calls)\n * into the dotted hub action path. Returns `undefined` when the name is not a\n * catalog integration tool, so the chat loop routes non-integration calls\n * elsewhere instead of misrouting them to the hub.\n */\nexport function resolveIntegrationAction(toolName: string): ParsedIntegrationAction | undefined {\n  let parsed: { providerId: string; connectorId: string; actionId: string }\n  try {\n    parsed = parseIntegrationToolName(toolName)\n  } catch {\n    return undefined\n  }\n  if (!parsed.providerId || !parsed.connectorId || !parsed.actionId) return undefined\n  return { ...parsed, path: `${parsed.providerId}.${parsed.connectorId}.${parsed.actionId}` }\n}\n\ninterface HubEnvelope {\n  success: boolean\n  data?: { result?: unknown }\n  error?: { code?: string; message?: string; details?: { approval?: unknown } }\n}\n\n/** Typed client over the platform hub `/v1/hub/exec`. The hub holds the user's\n *  credentials, resolves the connection from the bearer principal, evaluates\n *  per-action policy (read → allow, write/destructive → approval), and runs the\n *  action server-side. Never throws on a policy block — a gated write is a\n *  normal `succeeded: false` outcome. */\nexport class HubExecClient {\n  private readonly baseUrl: string\n  private readonly bearer: string\n  private readonly fetchImpl: typeof fetch\n\n  constructor(options: HubExecClientOptions) {\n    if (!options.baseUrl) throw new Error('HubExecClient: baseUrl is required')\n    if (!options.bearer) throw new Error('HubExecClient: bearer is required')\n    this.baseUrl = options.baseUrl.replace(/\\/+$/, '')\n    this.bearer = options.bearer\n    this.fetchImpl = options.fetchImpl ?? fetch\n  }\n\n  async exec(input: { path: string; actionInput?: unknown; connectionId?: string }): Promise<HubExecResult> {\n    const response = await this.fetchImpl(`${this.baseUrl}/v1/hub/exec`, {\n      method: 'POST',\n      headers: { Authorization: `Bearer ${this.bearer}`, 'Content-Type': 'application/json', Accept: 'application/json' },\n      body: JSON.stringify({ path: input.path, input: input.actionInput, connectionId: input.connectionId }),\n    })\n    const envelope = await this.readEnvelope(response)\n    if (response.ok && envelope.success) return { succeeded: true, result: envelope.data?.result }\n    return {\n      succeeded: false,\n      code: envelope.error?.code ?? `HUB_HTTP_${response.status}`,\n      message: envelope.error?.message ?? `Hub /exec returned ${response.status}`,\n      approval: envelope.error?.details?.approval,\n    }\n  }\n\n  private async readEnvelope(response: Response): Promise<HubEnvelope> {\n    const text = await response.text()\n    if (!text) return { success: false, error: { code: `HUB_HTTP_${response.status}`, message: `Hub returned ${response.status} with no body` } }\n    try {\n      return JSON.parse(text) as HubEnvelope\n    } catch {\n      return { success: false, error: { code: 'HUB_BAD_RESPONSE', message: `Hub returned non-JSON (${response.status}): ${text.slice(0, 200)}` } }\n    }\n  }\n}\n\n/** Define input parameters for invoking a hub tool with user ID, tool name, and optional arguments */\nexport interface HubInvokeInput {\n  userId: string\n  /** The MCP tool name the agent called (`int_<provider>_<connector>_<action>`). */\n  toolName: string\n  args?: Record<string, unknown>\n}\n/** Describe the outcome of a hub invocation including status and response body */\nexport interface HubInvokeOutcome {\n  status: number\n  body: Record<string, unknown>\n}\n/** Define dependencies for invoking hub operations including API key resolution and optional configuration */\nexport interface HubInvokeDeps {\n  /** Resolve the user's Tangle API key (the hub principal bearer). Required —\n   *  the product binds its own session-key resolver. Null → user not linked. */\n  apiKeyResolver: (userId: string) => Promise<string | null>\n  /** Platform base URL. Defaults to `env.TANGLE_PLATFORM_URL`. */\n  baseUrl?: string\n  fetchImpl?: typeof fetch\n  env?: Record<string, string | undefined>\n}\n\n/**\n * Resolve + execute one integration tool call through the hub: resolve the\n * per-user bearer, map the MCP tool name to the hub action path, forward to\n * `/v1/hub/exec`, and shape the route response (200 ok / 401 not-linked /\n * 400 unknown-tool / 409 approval-required / 502 hub-error). A write that's\n * approval-gated surfaces verbatim as 409, never silently executed.\n */\nexport async function invokeIntegrationHub(input: HubInvokeInput, deps: HubInvokeDeps): Promise<HubInvokeOutcome> {\n  const env = deps.env ?? (process.env as Record<string, string | undefined>)\n  const baseUrl = deps.baseUrl ?? env.TANGLE_PLATFORM_URL?.trim()\n  if (!baseUrl) return { status: 500, body: { error: 'TANGLE_PLATFORM_URL is not configured' } }\n\n  const action = resolveIntegrationAction(input.toolName)\n  if (!action) return { status: 400, body: { error: `Unsupported integration tool: ${input.toolName}` } }\n\n  const bearer = await deps.apiKeyResolver(input.userId)\n  if (!bearer) return { status: 401, body: { error: 'Tangle account not linked — connect integrations from the app first' } }\n\n  const client = new HubExecClient({ baseUrl, bearer, fetchImpl: deps.fetchImpl })\n  const outcome = await client.exec({ path: action.path, actionInput: input.args ?? {} })\n\n  if (outcome.succeeded) {\n    return { status: 200, body: { success: true, path: action.path, providerId: action.providerId, action: action.actionId, result: outcome.result } }\n  }\n  const status = outcome.code === 'HUB_APPROVAL_REQUIRED' ? 409 : 502\n  return {\n    status,\n    body: { success: false, path: action.path, code: outcome.code, error: outcome.message, ...(outcome.approval ? { approval: outcome.approval } : {}) },\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/interactions/index.d.ts

@@ -1,5 +1,5 @@
-import { l as InteractionRequestWire } from '../contract-B3h7peV3.js';
-export { C as ChatFreeTextField, a as ChatInteraction, b as ChatInteractionField, c as ChatInteractionStatus, d as ChatSelectField, e as ComposerAnswerDelivery, I as INTERACTION_CANCEL_EVENT, f as INTERACTION_EVENT, g as INTERACTION_RESOLVED_EVENT, h as InteractionAnswerValue, i as InteractionAnswers, j as InteractionCancelData, k as InteractionPersistedPart, N as NoticeKind, m as NoticePersistedPart, P as ParseInteractionAnswersResult, n as ParseInteractionResult, o as canTransitionInteractionStatus, p as cancelStatusFor, q as composerAnswerData, r as composerAnswerDeliveries, s as dedupeQuestionInteractionsByContent, t as fieldAcceptsFreeText, u as interactionFromWireRequest, v as interactionPartKey, w as interactionToPersistedPart, x as isRenderableInteractionKind, y as isSafeInteractionFieldKey, z as isTerminalInteractionStatus, A as noticePart, B as noticePartKey, D as parseInteractionAnswers, E as parseInteractionCancel, F as parseInteractionRequest, G as persistedPartToInteraction, H as questionInteractionContentSignature, J as stampInteractionAnswers } from '../contract-B3h7peV3.js';
+import { e as InteractionRequestWire } from '../contract-CEewO6DI.js';
+export { f as ChatFreeTextField, b as ChatInteraction, a as ChatInteractionField, C as ChatInteractionStatus, d as ChatSelectField, g as ComposerAnswerDelivery, h as INTERACTION_CANCEL_EVENT, i as INTERACTION_EVENT, j as INTERACTION_RESOLVED_EVENT, k as InteractionAnswerValue, I as InteractionAnswers, c as InteractionCancelData, l as InteractionPersistedPart, N as NoticeKind, m as NoticePersistedPart, P as ParseInteractionAnswersResult, n as ParseInteractionResult, o as canTransitionInteractionStatus, p as cancelStatusFor, q as composerAnswerData, r as composerAnswerDeliveries, s as dedupeQuestionInteractionsByContent, t as fieldAcceptsFreeText, u as interactionFromWireRequest, v as interactionPartKey, w as interactionToPersistedPart, x as isRenderableInteractionKind, y as isSafeInteractionFieldKey, z as isTerminalInteractionStatus, A as noticePart, B as noticePartKey, D as parseInteractionAnswers, E as parseInteractionCancel, F as parseInteractionRequest, G as persistedPartToInteraction, H as questionInteractionContentSignature, J as stampInteractionAnswers } from '../contract-CEewO6DI.js';
 import { InteractionOutcome, InteractionData } from '@tangle-network/agent-interface';
 export { InteractionData, InteractionOutcome, InteractionRequest } from '@tangle-network/agent-interface';
 
@@ -146,8 +146,10 @@ interface DurableInteractionRouteArgs extends BeforeInteractionAnswerArgs {
     attemptKey: string;
 }
 /** Crash-recoverable persistence lifecycle for the answer route. The product
- * binds this structural port to `/durable-chat` (or an equivalent durable
- * store). Existing `beforeAnswer` behavior remains independent and unchanged. */
+ * binds this structural port to its OWN durable store — agent-app ships no
+ * implementation (the `/durable-chat` module that used to provide one was
+ * removed in 0.44.0 after nine repos produced zero imports of it). Existing
+ * `beforeAnswer` behavior remains independent and unchanged. */
 interface DurableInteractionRoutePersistence<TPrepared = unknown> {
     guarantee: 'reconciled' | 'best-effort';
     prepare(args: DurableInteractionRouteArgs): TPrepared | Promise<TPrepared>;

package/dist/interactions/index.js

@@ -1,11 +1,10 @@
-import "../chunk-7LNGJDNA.js";
 import {
   createInteractionAnswerRoute,
   listSessionInteractions,
   mapInteractionRespondFailure,
   respondToSessionInteraction,
   validateInteractionAnswerBody
-} from "../chunk-3JUTOVUH.js";
+} from "../chunk-6KMAM7BL.js";
 import {
   INTERACTION_CANCEL_EVENT,
   INTERACTION_EVENT,

package/dist/knowledge/index.js

@@ -1,7 +1,66 @@
-import {
-  buildKnowledgeRequirements,
-  deriveSignals
-} from "../chunk-AP2UXKUK.js";
+// src/knowledge/index.ts
+function clamp(value) {
+  if (!Number.isFinite(value)) return 0;
+  if (value < 0) return 0;
+  if (value > 1) return 1;
+  return value;
+}
+function buildKnowledgeRequirements(specs, signals = {}) {
+  return specs.map((spec) => {
+    const signal = signals[spec.id];
+    return {
+      id: spec.id,
+      description: spec.description,
+      requiredFor: spec.requiredFor ?? [],
+      category: spec.category,
+      acquisitionMode: spec.acquisitionMode,
+      importance: spec.importance ?? "blocking",
+      freshness: spec.freshness ?? "static",
+      sensitivity: spec.sensitivity ?? "private",
+      confidenceNeeded: spec.confidenceNeeded ?? 1,
+      currentConfidence: clamp(signal?.confidence ?? 0),
+      evidenceIds: signal?.evidence ? [signal.evidence] : [],
+      fallbackPolicy: spec.acquisitionMode === "ask_user" ? "ask" : "block"
+    };
+  });
+}
+async function deriveSignals(specs, ctx) {
+  const out = {};
+  for (const spec of specs) {
+    if (spec.derive) {
+      out[spec.id] = { confidence: clamp(await spec.derive(ctx)), evidence: spec.evidence };
+    } else if (spec.satisfiedBy) {
+      const ok = await evalRule(spec.satisfiedBy, ctx);
+      out[spec.id] = ok ? { confidence: 1, evidence: spec.evidence ?? describeRule(spec.satisfiedBy) } : { confidence: 0 };
+    } else {
+      out[spec.id] = { confidence: 0 };
+    }
+  }
+  return out;
+}
+async function evalRule(rule, ctx) {
+  if ("anyOf" in rule) {
+    for (const sub of rule.anyOf) if (await evalRule(sub, ctx)) return true;
+    return false;
+  }
+  if ("allOf" in rule) {
+    for (const sub of rule.allOf) if (!await evalRule(sub, ctx)) return false;
+    return true;
+  }
+  if ("config" in rule) {
+    const value = ctx.config(rule.config);
+    if (rule.nonEmpty) return Array.isArray(value) ? value.length > 0 : value != null && value !== "";
+    return value != null && value !== "" && value !== false;
+  }
+  const rows = await ctx.count({ table: rule.table, where: rule.where, statusIn: rule.statusIn });
+  return rows >= (rule.minRows ?? 1);
+}
+function describeRule(rule) {
+  if ("anyOf" in rule) return `anyOf(${rule.anyOf.map(describeRule).join(",")})`;
+  if ("allOf" in rule) return `allOf(${rule.allOf.map(describeRule).join(",")})`;
+  if ("config" in rule) return `config:${rule.config}`;
+  return `${rule.table}${rule.statusIn ? `[${rule.statusIn.join("|")}]` : ""}>=${rule.minRows ?? 1}`;
+}
 export {
   buildKnowledgeRequirements,
   deriveSignals

package/dist/knowledge/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}
+{"version":3,"sources":["../../src/knowledge/index.ts"],"sourcesContent":["/**\n * Declarative knowledge-requirement gate.\n *\n * Every agent product hand-rolls the same pair: a `buildXKnowledgeRequirements`\n * declaring the requirements that gate its control loop, and a\n * `deriveXRuntimeKnowledge` that scores each one from workspace state. Across\n * the fleet those derives are uniformly \"is a config field set\" / \"are there\n * >= N rows in table T (optionally with a status filter)\" / \"any/all of the\n * above\" — data, not logic. This module makes both DATA: a spec list with\n * declarative `satisfiedBy` rules, plus a per-spec `derive` escape hatch for\n * the rare rule a declarative form can't express (e.g. an aggregate over a\n * JSON column).\n *\n * Substrate-free: the only seam is `KnowledgeStateAccessor` (a config lookup +\n * a row count), which the consumer's backend — or `agent-app/preset-cloudflare`\n * — implements. Emits `@tangle-network/agent-eval`'s `KnowledgeRequirement[]`,\n * exactly what the agent-runtime control loop consumes.\n */\n\nimport type {\n  KnowledgeAcquisitionMode,\n  KnowledgeFreshness,\n  KnowledgeImportance,\n  KnowledgeRequirement,\n  KnowledgeRequirementCategory,\n  KnowledgeSensitivity,\n} from '@tangle-network/agent-eval'\n\n/** A declarative rule for satisfying a requirement from workspace state. */\nexport type SatisfiedByRule =\n  /** A workspace-config field (dot-path) is set. `nonEmpty` requires a\n   *  non-empty array/string rather than mere presence. */\n  | { config: string; nonEmpty?: boolean }\n  /** At least `minRows` (default 1) rows exist in `table` for the workspace,\n   *  optionally filtered to `statusIn`. `where` names the workspace fk column\n   *  the accessor scopes on (default: the accessor's convention). */\n  | { table: string; where?: string; statusIn?: string[]; minRows?: number }\n  | { anyOf: SatisfiedByRule[] }\n  | { allOf: SatisfiedByRule[] }\n\n/** Define the criteria and conditions required to satisfy a specific knowledge requirement */\nexport interface KnowledgeRequirementSpec {\n  id: string\n  description: string\n  category: KnowledgeRequirementCategory\n  acquisitionMode: KnowledgeAcquisitionMode\n  importance?: KnowledgeImportance\n  freshness?: KnowledgeFreshness\n  sensitivity?: KnowledgeSensitivity\n  confidenceNeeded?: number\n  requiredFor?: string[]\n  /** The data path — evaluated against the `KnowledgeStateAccessor`. */\n  satisfiedBy?: SatisfiedByRule\n  /** The escape hatch — a code derive for what a rule can't express. Wins\n   *  over `satisfiedBy` when both are present. Returns confidence in [0, 1]. */\n  derive?: (ctx: KnowledgeStateAccessor) => number | Promise<number>\n  /** Evidence id attached when satisfied (default: a description of the rule). */\n  evidence?: string\n}\n\n/** The single seam a backend implements. `preset-cloudflare` provides a D1\n *  implementation; a custom stack supplies its own. */\nexport interface KnowledgeStateAccessor {\n  /** Resolve a workspace-config field value (dot-path), or undefined. */\n  config: (path: string) => unknown\n  /** Count rows in `table` for the active workspace, optionally status-filtered. */\n  count: (query: { table: string; where?: string; statusIn?: string[] }) => number | Promise<number>\n}\n\n/** Define a signal representing knowledge with confidence level and optional supporting evidence */\nexport interface KnowledgeSignal {\n  confidence: number\n  evidence?: string\n}\n\nfunction clamp(value: number): number {\n  if (!Number.isFinite(value)) return 0\n  if (value < 0) return 0\n  if (value > 1) return 1\n  return value\n}\n\n/**\n * Map specs -> the runtime's `KnowledgeRequirement[]`, folding in per-spec\n * confidence from `signals` (default 0). Pure + sync: an eval harness can pass\n * hand-authored signals; production passes the output of {@link deriveSignals}.\n */\nexport function buildKnowledgeRequirements(\n  specs: KnowledgeRequirementSpec[],\n  signals: Record<string, KnowledgeSignal> = {},\n): KnowledgeRequirement[] {\n  return specs.map((spec) => {\n    const signal = signals[spec.id]\n    return {\n      id: spec.id,\n      description: spec.description,\n      requiredFor: spec.requiredFor ?? [],\n      category: spec.category,\n      acquisitionMode: spec.acquisitionMode,\n      importance: spec.importance ?? 'blocking',\n      freshness: spec.freshness ?? 'static',\n      sensitivity: spec.sensitivity ?? 'private',\n      confidenceNeeded: spec.confidenceNeeded ?? 1,\n      currentConfidence: clamp(signal?.confidence ?? 0),\n      evidenceIds: signal?.evidence ? [signal.evidence] : [],\n      fallbackPolicy: spec.acquisitionMode === 'ask_user' ? 'ask' : 'block',\n    }\n  })\n}\n\n/**\n * Score every spec from workspace state. `derive` (code) wins; otherwise the\n * declarative `satisfiedBy` rule is evaluated through the accessor; a spec with\n * neither scores 0 (an acquisition gate, e.g. `search_web`).\n */\nexport async function deriveSignals(\n  specs: KnowledgeRequirementSpec[],\n  ctx: KnowledgeStateAccessor,\n): Promise<Record<string, KnowledgeSignal>> {\n  const out: Record<string, KnowledgeSignal> = {}\n  for (const spec of specs) {\n    if (spec.derive) {\n      out[spec.id] = { confidence: clamp(await spec.derive(ctx)), evidence: spec.evidence }\n    } else if (spec.satisfiedBy) {\n      const ok = await evalRule(spec.satisfiedBy, ctx)\n      out[spec.id] = ok\n        ? { confidence: 1, evidence: spec.evidence ?? describeRule(spec.satisfiedBy) }\n        : { confidence: 0 }\n    } else {\n      out[spec.id] = { confidence: 0 }\n    }\n  }\n  return out\n}\n\nasync function evalRule(rule: SatisfiedByRule, ctx: KnowledgeStateAccessor): Promise<boolean> {\n  if ('anyOf' in rule) {\n    for (const sub of rule.anyOf) if (await evalRule(sub, ctx)) return true\n    return false\n  }\n  if ('allOf' in rule) {\n    for (const sub of rule.allOf) if (!(await evalRule(sub, ctx))) return false\n    return true\n  }\n  if ('config' in rule) {\n    const value = ctx.config(rule.config)\n    if (rule.nonEmpty) return Array.isArray(value) ? value.length > 0 : value != null && value !== ''\n    return value != null && value !== '' && value !== false\n  }\n  const rows = await ctx.count({ table: rule.table, where: rule.where, statusIn: rule.statusIn })\n  return rows >= (rule.minRows ?? 1)\n}\n\nfunction describeRule(rule: SatisfiedByRule): string {\n  if ('anyOf' in rule) return `anyOf(${rule.anyOf.map(describeRule).join(',')})`\n  if ('allOf' in rule) return `allOf(${rule.allOf.map(describeRule).join(',')})`\n  if ('config' in rule) return `config:${rule.config}`\n  return `${rule.table}${rule.statusIn ? `[${rule.statusIn.join('|')}]` : ''}>=${rule.minRows ?? 1}`\n}\n"],"mappings":";AA2EA,SAAS,MAAM,OAAuB;AACpC,MAAI,CAAC,OAAO,SAAS,KAAK,EAAG,QAAO;AACpC,MAAI,QAAQ,EAAG,QAAO;AACtB,MAAI,QAAQ,EAAG,QAAO;AACtB,SAAO;AACT;AAOO,SAAS,2BACd,OACA,UAA2C,CAAC,GACpB;AACxB,SAAO,MAAM,IAAI,CAAC,SAAS;AACzB,UAAM,SAAS,QAAQ,KAAK,EAAE;AAC9B,WAAO;AAAA,MACL,IAAI,KAAK;AAAA,MACT,aAAa,KAAK;AAAA,MAClB,aAAa,KAAK,eAAe,CAAC;AAAA,MAClC,UAAU,KAAK;AAAA,MACf,iBAAiB,KAAK;AAAA,MACtB,YAAY,KAAK,cAAc;AAAA,MAC/B,WAAW,KAAK,aAAa;AAAA,MAC7B,aAAa,KAAK,eAAe;AAAA,MACjC,kBAAkB,KAAK,oBAAoB;AAAA,MAC3C,mBAAmB,MAAM,QAAQ,cAAc,CAAC;AAAA,MAChD,aAAa,QAAQ,WAAW,CAAC,OAAO,QAAQ,IAAI,CAAC;AAAA,MACrD,gBAAgB,KAAK,oBAAoB,aAAa,QAAQ;AAAA,IAChE;AAAA,EACF,CAAC;AACH;AAOA,eAAsB,cACpB,OACA,KAC0C;AAC1C,QAAM,MAAuC,CAAC;AAC9C,aAAW,QAAQ,OAAO;AACxB,QAAI,KAAK,QAAQ;AACf,UAAI,KAAK,EAAE,IAAI,EAAE,YAAY,MAAM,MAAM,KAAK,OAAO,GAAG,CAAC,GAAG,UAAU,KAAK,SAAS;AAAA,IACtF,WAAW,KAAK,aAAa;AAC3B,YAAM,KAAK,MAAM,SAAS,KAAK,aAAa,GAAG;AAC/C,UAAI,KAAK,EAAE,IAAI,KACX,EAAE,YAAY,GAAG,UAAU,KAAK,YAAY,aAAa,KAAK,WAAW,EAAE,IAC3E,EAAE,YAAY,EAAE;AAAA,IACtB,OAAO;AACL,UAAI,KAAK,EAAE,IAAI,EAAE,YAAY,EAAE;AAAA,IACjC;AAAA,EACF;AACA,SAAO;AACT;AAEA,eAAe,SAAS,MAAuB,KAA+C;AAC5F,MAAI,WAAW,MAAM;AACnB,eAAW,OAAO,KAAK,MAAO,KAAI,MAAM,SAAS,KAAK,GAAG,EAAG,QAAO;AACnE,WAAO;AAAA,EACT;AACA,MAAI,WAAW,MAAM;AACnB,eAAW,OAAO,KAAK,MAAO,KAAI,CAAE,MAAM,SAAS,KAAK,GAAG,EAAI,QAAO;AACtE,WAAO;AAAA,EACT;AACA,MAAI,YAAY,MAAM;AACpB,UAAM,QAAQ,IAAI,OAAO,KAAK,MAAM;AACpC,QAAI,KAAK,SAAU,QAAO,MAAM,QAAQ,KAAK,IAAI,MAAM,SAAS,IAAI,SAAS,QAAQ,UAAU;AAC/F,WAAO,SAAS,QAAQ,UAAU,MAAM,UAAU;AAAA,EACpD;AACA,QAAM,OAAO,MAAM,IAAI,MAAM,EAAE,OAAO,KAAK,OAAO,OAAO,KAAK,OAAO,UAAU,KAAK,SAAS,CAAC;AAC9F,SAAO,SAAS,KAAK,WAAW;AAClC;AAEA,SAAS,aAAa,MAA+B;AACnD,MAAI,WAAW,KAAM,QAAO,SAAS,KAAK,MAAM,IAAI,YAAY,EAAE,KAAK,GAAG,CAAC;AAC3E,MAAI,WAAW,KAAM,QAAO,SAAS,KAAK,MAAM,IAAI,YAAY,EAAE,KAAK,GAAG,CAAC;AAC3E,MAAI,YAAY,KAAM,QAAO,UAAU,KAAK,MAAM;AAClD,SAAO,GAAG,KAAK,KAAK,GAAG,KAAK,WAAW,IAAI,KAAK,SAAS,KAAK,GAAG,CAAC,MAAM,EAAE,KAAK,KAAK,WAAW,CAAC;AAClG;","names":[]}

package/dist/knowledge-loop/index.d.ts

@@ -2,7 +2,7 @@ import { KnowledgeResearchLoopContext, AddSourceTextInput, SourceAdapter, RunKno
 import { KnowledgeSourceSpec, AgentKnowledgeConfig } from '../config/index.js';
 import '../knowledge/index.js';
 import '@tangle-network/agent-eval';
-import '../model-DmdkIteM.js';
+import '../model-CdCDfBA9.js';
 
 /**
  * `@tangle-network/agent-app/knowledge-loop` — wire the declarative