@tangle-network/agent-app 0.43.76 → 0.44.1

package/dist/knowledge-loop/index.js

@@ -1,8 +1,98 @@
+// src/knowledge-loop/index.ts
 import {
-  createKnowledgeLoop,
-  createReviewerDecider,
-  reviewCandidate
-} from "../chunk-GPBRL2XR.js";
+  runKnowledgeResearchLoop,
+  textSourceAdapter
+} from "@tangle-network/agent-knowledge";
+var DEFAULT_MIN_CONFIDENCE = 0.7;
+var DEFAULT_GOAL = "Acquire and ground the knowledge this product requires.";
+function reviewCandidate(candidate, minConfidence) {
+  if (!candidate.proposalText) {
+    return {
+      accepted: true,
+      reason: "no-proposal",
+      confidence: candidate.confidence ?? 1,
+      minConfidence
+    };
+  }
+  const confidence = candidate.confidence ?? 0;
+  if (confidence >= minConfidence) {
+    return {
+      accepted: true,
+      reason: `confidence ${confidence.toFixed(2)} >= minConfidence ${minConfidence.toFixed(2)}`,
+      confidence,
+      minConfidence
+    };
+  }
+  return {
+    accepted: false,
+    reason: `confidence ${confidence.toFixed(2)} < minConfidence ${minConfidence.toFixed(2)}`,
+    confidence,
+    minConfidence
+  };
+}
+function createReviewerDecider(propose) {
+  return async (input) => {
+    const candidate = await propose(input);
+    const verdict = reviewCandidate(candidate, input.minConfidence);
+    return { candidate, verdict };
+  };
+}
+function toResearchDecision(decision) {
+  const { candidate, verdict } = decision;
+  return {
+    notes: candidate.notes,
+    sourcePaths: candidate.sourcePaths,
+    sourceTexts: candidate.sourceTexts,
+    proposalText: verdict.accepted ? candidate.proposalText : void 0,
+    done: candidate.done,
+    metadata: {
+      ...candidate.metadata ?? {},
+      gate: verdict
+    }
+  };
+}
+var noopDecider = (input) => ({
+  candidate: { done: true, notes: "no decider supplied; nothing proposed" },
+  verdict: {
+    accepted: true,
+    reason: "no-proposal",
+    confidence: 1,
+    minConfidence: input.minConfidence
+  }
+});
+function createKnowledgeLoop(knowledge, deps) {
+  const goal = knowledge.loop?.goal ?? deps.defaultGoal ?? DEFAULT_GOAL;
+  const minConfidence = knowledge.loop?.minConfidence ?? deps.defaultMinConfidence ?? DEFAULT_MIN_CONFIDENCE;
+  const freshness = knowledge.loop?.freshness;
+  const adapters = [...deps.adapters ?? [], textSourceAdapter];
+  const decide = deps.decide ?? noopDecider;
+  const run = () => runKnowledgeResearchLoop({
+    root: deps.root,
+    goal,
+    maxIterations: deps.maxIterations,
+    actor: deps.actor,
+    signal: deps.signal,
+    onStep: deps.onStep,
+    sourceOptions: { adapters },
+    async step(context) {
+      const decision = await decide({
+        context,
+        goal,
+        minConfidence,
+        freshness,
+        sources: knowledge.sources,
+        driver: deps.driver
+      });
+      return toResearchDecision(decision);
+    }
+  });
+  return {
+    run,
+    goal,
+    minConfidence,
+    adapters
+  };
+}
 export {
   createKnowledgeLoop,
   createReviewerDecider,

package/dist/knowledge-loop/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}
+{"version":3,"sources":["../../src/knowledge-loop/index.ts"],"sourcesContent":["/**\n * `@tangle-network/agent-app/knowledge-loop` — wire the declarative\n * `AgentKnowledgeConfig` to a running, source-grounded, eval-gated knowledge\n * acquisition loop.\n *\n * This module does NOT implement a loop. `@tangle-network/agent-knowledge`\n * already ships `runKnowledgeResearchLoop` — the source-grounded,\n * propose-don't-apply primitive (sources become immutable records first; only\n * accepted `---FILE: knowledge/...---` write blocks are applied; lint +\n * validation + optional readiness gate every iteration). It is pluggable on two\n * seams: a `SourceAdapter[]` (how raw bytes/text become curated source records —\n * text by default, audio/video/image adapters added by the consumer) and a\n * `step` decider (the per-iteration policy: an agentic judge, a sandbox run, or\n * a deterministic gate — the loop deliberately bakes none).\n *\n * `createKnowledgeLoop(config.knowledge, deps)` is the thin mapper between the\n * two:\n *\n *  - `config.knowledge.sources` → adapter selection. The text adapter is the\n *    default; `deps.adapters` is the multimodal seam (prepend an audio/video/\n *    image `SourceAdapter` and the loop ingests that media). agent-app bakes no\n *    media handler — it's a parameter.\n *  - `config.knowledge.loop` → `runKnowledgeResearchLoop` options. `goal` maps\n *    to the loop goal, `minConfidence` to the gate threshold, `freshness` is\n *    threaded to the decider so a per-source-freshness policy can read it.\n *  - `deps.decide` → the pluggable gate. DEFAULT is a reviewer policy\n *    (agent-knowledge's propose-don't-apply posture): a candidate carrying\n *    confidence below `minConfidence` is gated OUT (its proposal text is\n *    dropped — sources are still recorded, because grounding is never the thing\n *    we gate); at/above threshold it is accepted and the loop applies the write\n *    blocks. Swap in an agentic judge or a sandbox run by passing your own\n *    `decide`.\n *  - `deps.driver` → the agent-runtime turn driver (this repo's `../runtime`\n *    `runAppToolLoop` seam, or any compatible driver) the decider invokes for\n *    the loop's agent turns. Optional; a deterministic / sandbox decider needs\n *    no model turns and omits it.\n *\n * Layering: agent-knowledge and agent-runtime are PEER dependencies, never\n * bundled. This module imports only TYPES + the loop entry from agent-knowledge\n * and stays substrate-free behind the `decide` / `driver` / `adapters` seams.\n */\n\nimport type {\n  AddSourceTextInput,\n  KnowledgeResearchLoopContext,\n  KnowledgeResearchLoopDecision,\n  KnowledgeResearchLoopResult,\n  RunKnowledgeResearchLoopOptions,\n  SourceAdapter,\n} from '@tangle-network/agent-knowledge'\nimport {\n  runKnowledgeResearchLoop,\n  textSourceAdapter,\n} from '@tangle-network/agent-knowledge'\nimport type { AgentKnowledgeConfig, KnowledgeSourceSpec } from '../config/index'\n\n/**\n * A research candidate the decider evaluates before the loop applies it. This is\n * the propose-don't-apply unit: notes + the sources discovered this iteration +\n * the proposed write blocks, each carrying a confidence the gate scores against\n * the configured `minConfidence`.\n */\nexport interface KnowledgeCandidate {\n  /** Human-readable research transcript for this iteration. */\n  notes?: string\n  /**\n   * Textual source artifacts to register as immutable sources BEFORE any\n   * proposal is applied. Recording these is grounding, not the gated step — a\n   * rejected candidate still keeps its sources (so the next iteration is better\n   * grounded). The decider may not strip these.\n   */\n  sourceTexts?: AddSourceTextInput[]\n  /** Local files to register as immutable sources (same grounding posture). */\n  sourcePaths?: string[]\n  /**\n   * Safe-write-protocol text (`---FILE: knowledge/...---` blocks). This IS the\n   * gated step: the default decider drops it when `confidence < minConfidence`.\n   */\n  proposalText?: string\n  /**\n   * Aggregate confidence in this candidate's proposal, in [0, 1]. The default\n   * reviewer gate compares this to `minConfidence`. A candidate with no\n   * `proposalText` needs no confidence (nothing is gated).\n   */\n  confidence?: number\n  /** The researcher's signal that the goal is met; ends the loop. */\n  done?: boolean\n  metadata?: Record<string, unknown>\n}\n\n/** The verdict a gate returns for one candidate. */\nexport interface KnowledgeGateVerdict {\n  /** Whether the candidate's proposal is accepted (applied) or gated out. */\n  accepted: boolean\n  /** Why — surfaced in the decision metadata for audit. */\n  reason: string\n  /** The confidence the gate scored (echoed for telemetry). */\n  confidence: number\n  /** The threshold it was scored against. */\n  minConfidence: number\n}\n\n/**\n * The pluggable acquisition policy. Given the loop context (current index, lint,\n * validation, freshness target, the driver), produce a candidate AND a gate\n * verdict on it. This is the seam an agentic judge or a sandbox run plugs into;\n * the default {@link createReviewerDecider} is a confidence gate.\n */\nexport interface KnowledgeDecider {\n  (input: KnowledgeDeciderInput): Promise<KnowledgeDecision> | KnowledgeDecision\n}\n\n/** Define the input parameters required to decide knowledge proposals within an agent-knowledge loop */\nexport interface KnowledgeDeciderInput {\n  /** The agent-knowledge loop context for this iteration. */\n  context: KnowledgeResearchLoopContext\n  /** The acquisition goal (from `config.loop.goal` or a deps fallback). */\n  goal: string\n  /** The confidence threshold a proposal must clear to be applied. */\n  minConfidence: number\n  /** The freshness target (`config.loop.freshness`), if set. */\n  freshness?: string\n  /** The configured sources, for a decider that fetches/selects among them. */\n  sources: KnowledgeSourceSpec[]\n  /** The agent-runtime turn driver, if one was supplied to the loop. */\n  driver?: KnowledgeLoopDriver\n}\n\n/** Define a decision containing a candidate and the gate's verdict on that candidate */\nexport interface KnowledgeDecision {\n  /** The candidate the policy produced (may be empty to end the loop). */\n  candidate: KnowledgeCandidate\n  /** The gate's verdict on the candidate's proposal. */\n  verdict: KnowledgeGateVerdict\n}\n\n/**\n * The agent-runtime turn driver seam. This is exactly `../runtime`'s\n * `runAppToolLoop` shape (a bounded, awaitable tool-driving turn loop over a\n * model). Typed structurally so a decider can drive the loop's agent turns\n * without this module importing the runtime engine. A deterministic / sandbox\n * decider may omit it.\n */\nexport interface KnowledgeLoopDriver {\n  (opts: {\n    systemPrompt: string\n    userMessage: string\n  }): Promise<{ finalText: string }>\n}\n\n/** Define dependencies required to create and run a knowledge processing loop */\nexport interface CreateKnowledgeLoopDeps {\n  /**\n   * The knowledge-base root the loop reads/writes (an agent-knowledge layout).\n   * Required — agent-knowledge owns disk; agent-app owns only the wiring.\n   */\n  root: string\n  /**\n   * The per-iteration policy. Defaults to {@link createReviewerDecider} keyed on\n   * the config's `minConfidence`. Pass your own to use an agentic judge or a\n   * sandbox run.\n   */\n  decide?: KnowledgeDecider\n  /**\n   * Extra source adapters (audio/video/image/PDF/...). The text adapter is\n   * always present as the fallback; these are tried first so a multimodal\n   * source is claimed by its adapter. This is the multimodal seam.\n   */\n  adapters?: SourceAdapter[]\n  /** The agent-runtime turn driver for the loop's agent turns. */\n  driver?: KnowledgeLoopDriver\n  /**\n   * Fallback goal when `config.loop.goal` is unset. agent-knowledge requires a\n   * goal; this keeps the loop runnable for a config with only requirement specs.\n   */\n  defaultGoal?: string\n  /** Default confidence threshold when `config.loop.minConfidence` is unset. */\n  defaultMinConfidence?: number\n  /** Max research iterations (forwarded to agent-knowledge). Default 3. */\n  maxIterations?: number\n  /** Actor stamped on the loop's knowledge events. */\n  actor?: string\n  /** Abort the loop. */\n  signal?: AbortSignal\n  /** Per-step hook (forwarded to agent-knowledge's `onStep`). */\n  onStep?: RunKnowledgeResearchLoopOptions['onStep']\n}\n\n/** The handle `createKnowledgeLoop` returns. */\nexport interface KnowledgeLoop {\n  /** Run the acquisition loop to completion and return the agent-knowledge result. */\n  run(): Promise<KnowledgeResearchLoopResult>\n  /** The resolved goal the loop pursues. */\n  readonly goal: string\n  /** The resolved confidence gate threshold. */\n  readonly minConfidence: number\n  /** The adapters the loop uses (consumer extras first, text last). */\n  readonly adapters: SourceAdapter[]\n}\n\nconst DEFAULT_MIN_CONFIDENCE = 0.7\nconst DEFAULT_GOAL = 'Acquire and ground the knowledge this product requires.'\n\n/**\n * The default gate — agent-knowledge's propose-don't-apply reviewer posture as a\n * confidence threshold. A candidate's `proposalText` is applied only when its\n * `confidence` is at/above `minConfidence`; otherwise the proposal is gated out\n * (sources are still recorded). A candidate with no `proposalText` is trivially\n * accepted (nothing to gate). This is the floor policy; swap in an agentic judge\n * or a sandbox-run decider via `deps.decide` for richer review.\n */\nexport function reviewCandidate(\n  candidate: KnowledgeCandidate,\n  minConfidence: number,\n): KnowledgeGateVerdict {\n  if (!candidate.proposalText) {\n    return {\n      accepted: true,\n      reason: 'no-proposal',\n      confidence: candidate.confidence ?? 1,\n      minConfidence,\n    }\n  }\n  const confidence = candidate.confidence ?? 0\n  if (confidence >= minConfidence) {\n    return {\n      accepted: true,\n      reason: `confidence ${confidence.toFixed(2)} >= minConfidence ${minConfidence.toFixed(2)}`,\n      confidence,\n      minConfidence,\n    }\n  }\n  return {\n    accepted: false,\n    reason: `confidence ${confidence.toFixed(2)} < minConfidence ${minConfidence.toFixed(2)}`,\n    confidence,\n    minConfidence,\n  }\n}\n\n/**\n * Wrap a candidate-producing policy in the default reviewer gate. The policy\n * decides WHAT to propose (notes, sources, proposalText, confidence); the gate\n * decides whether the proposal is APPLIED. Use this when you have a proposer but\n * want the standard confidence gate; pass a full {@link KnowledgeDecider} to\n * `deps.decide` to own the gate too.\n */\nexport function createReviewerDecider(\n  propose: (\n    input: KnowledgeDeciderInput,\n  ) => Promise<KnowledgeCandidate> | KnowledgeCandidate,\n): KnowledgeDecider {\n  return async (input) => {\n    const candidate = await propose(input)\n    const verdict = reviewCandidate(candidate, input.minConfidence)\n    return { candidate, verdict }\n  }\n}\n\n/**\n * Apply a gate verdict to a candidate, producing the agent-knowledge decision.\n * Grounding (sources) always passes through; the gated `proposalText` is dropped\n * when the verdict rejects it. The verdict is recorded in `metadata.gate` so the\n * loop's event stream carries the audit trail.\n */\nfunction toResearchDecision(decision: KnowledgeDecision): KnowledgeResearchLoopDecision {\n  const { candidate, verdict } = decision\n  return {\n    notes: candidate.notes,\n    sourcePaths: candidate.sourcePaths,\n    sourceTexts: candidate.sourceTexts,\n    proposalText: verdict.accepted ? candidate.proposalText : undefined,\n    done: candidate.done,\n    metadata: {\n      ...(candidate.metadata ?? {}),\n      gate: verdict,\n    },\n  }\n}\n\n/**\n * The do-nothing default policy: when no `decide` is supplied, the loop runs\n * with a proposer that proposes nothing and ends immediately. A real product\n * supplies a proposer (agentic judge, sandbox run, or deterministic) via\n * `deps.decide`; this keeps `createKnowledgeLoop` total for a config that only\n * declares sources/requirements without a wired researcher yet.\n */\nconst noopDecider: KnowledgeDecider = (input) => ({\n  candidate: { done: true, notes: 'no decider supplied; nothing proposed' },\n  verdict: {\n    accepted: true,\n    reason: 'no-proposal',\n    confidence: 1,\n    minConfidence: input.minConfidence,\n  },\n})\n\n/**\n * Build a runnable knowledge-acquisition loop from the product's\n * `AgentKnowledgeConfig` and a small set of seams. Maps config → agent-knowledge\n * `runKnowledgeResearchLoop` options; never reimplements the loop.\n */\nexport function createKnowledgeLoop(\n  knowledge: AgentKnowledgeConfig,\n  deps: CreateKnowledgeLoopDeps,\n): KnowledgeLoop {\n  const goal = knowledge.loop?.goal ?? deps.defaultGoal ?? DEFAULT_GOAL\n  const minConfidence =\n    knowledge.loop?.minConfidence ?? deps.defaultMinConfidence ?? DEFAULT_MIN_CONFIDENCE\n  const freshness = knowledge.loop?.freshness\n\n  // Multimodal seam: consumer adapters are tried first; the text adapter is the\n  // always-present fallback (it claims text/.md/.txt/.json/.csv). A config\n  // source whose media an extra adapter claims is ingested by that adapter.\n  const adapters: SourceAdapter[] = [...(deps.adapters ?? []), textSourceAdapter]\n\n  const decide = deps.decide ?? noopDecider\n\n  const run = (): Promise<KnowledgeResearchLoopResult> =>\n    runKnowledgeResearchLoop({\n      root: deps.root,\n      goal,\n      maxIterations: deps.maxIterations,\n      actor: deps.actor,\n      signal: deps.signal,\n      onStep: deps.onStep,\n      sourceOptions: { adapters },\n      async step(context) {\n        const decision = await decide({\n          context,\n          goal,\n          minConfidence,\n          freshness,\n          sources: knowledge.sources,\n          driver: deps.driver,\n        })\n        return toResearchDecision(decision)\n      },\n    })\n\n  return {\n    run,\n    goal,\n    minConfidence,\n    adapters,\n  }\n}\n"],"mappings":";AAkDA;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAmJP,IAAM,yBAAyB;AAC/B,IAAM,eAAe;AAUd,SAAS,gBACd,WACA,eACsB;AACtB,MAAI,CAAC,UAAU,cAAc;AAC3B,WAAO;AAAA,MACL,UAAU;AAAA,MACV,QAAQ;AAAA,MACR,YAAY,UAAU,cAAc;AAAA,MACpC;AAAA,IACF;AAAA,EACF;AACA,QAAM,aAAa,UAAU,cAAc;AAC3C,MAAI,cAAc,eAAe;AAC/B,WAAO;AAAA,MACL,UAAU;AAAA,MACV,QAAQ,cAAc,WAAW,QAAQ,CAAC,CAAC,qBAAqB,cAAc,QAAQ,CAAC,CAAC;AAAA,MACxF;AAAA,MACA;AAAA,IACF;AAAA,EACF;AACA,SAAO;AAAA,IACL,UAAU;AAAA,IACV,QAAQ,cAAc,WAAW,QAAQ,CAAC,CAAC,oBAAoB,cAAc,QAAQ,CAAC,CAAC;AAAA,IACvF;AAAA,IACA;AAAA,EACF;AACF;AASO,SAAS,sBACd,SAGkB;AAClB,SAAO,OAAO,UAAU;AACtB,UAAM,YAAY,MAAM,QAAQ,KAAK;AACrC,UAAM,UAAU,gBAAgB,WAAW,MAAM,aAAa;AAC9D,WAAO,EAAE,WAAW,QAAQ;AAAA,EAC9B;AACF;AAQA,SAAS,mBAAmB,UAA4D;AACtF,QAAM,EAAE,WAAW,QAAQ,IAAI;AAC/B,SAAO;AAAA,IACL,OAAO,UAAU;AAAA,IACjB,aAAa,UAAU;AAAA,IACvB,aAAa,UAAU;AAAA,IACvB,cAAc,QAAQ,WAAW,UAAU,eAAe;AAAA,IAC1D,MAAM,UAAU;AAAA,IAChB,UAAU;AAAA,MACR,GAAI,UAAU,YAAY,CAAC;AAAA,MAC3B,MAAM;AAAA,IACR;AAAA,EACF;AACF;AASA,IAAM,cAAgC,CAAC,WAAW;AAAA,EAChD,WAAW,EAAE,MAAM,MAAM,OAAO,wCAAwC;AAAA,EACxE,SAAS;AAAA,IACP,UAAU;AAAA,IACV,QAAQ;AAAA,IACR,YAAY;AAAA,IACZ,eAAe,MAAM;AAAA,EACvB;AACF;AAOO,SAAS,oBACd,WACA,MACe;AACf,QAAM,OAAO,UAAU,MAAM,QAAQ,KAAK,eAAe;AACzD,QAAM,gBACJ,UAAU,MAAM,iBAAiB,KAAK,wBAAwB;AAChE,QAAM,YAAY,UAAU,MAAM;AAKlC,QAAM,WAA4B,CAAC,GAAI,KAAK,YAAY,CAAC,GAAI,iBAAiB;AAE9E,QAAM,SAAS,KAAK,UAAU;AAE9B,QAAM,MAAM,MACV,yBAAyB;AAAA,IACvB,MAAM,KAAK;AAAA,IACX;AAAA,IACA,eAAe,KAAK;AAAA,IACpB,OAAO,KAAK;AAAA,IACZ,QAAQ,KAAK;AAAA,IACb,QAAQ,KAAK;AAAA,IACb,eAAe,EAAE,SAAS;AAAA,IAC1B,MAAM,KAAK,SAAS;AAClB,YAAM,WAAW,MAAM,OAAO;AAAA,QAC5B;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA,SAAS,UAAU;AAAA,QACnB,QAAQ,KAAK;AAAA,MACf,CAAC;AACD,aAAO,mBAAmB,QAAQ;AAAA,IACpC;AAAA,EACF,CAAC;AAEH,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;","names":[]}

package/dist/{mcp-BjPqQ-3C.d.ts → mcp-D3qVzbE1.d.ts}

@@ -1,5 +1,5 @@
-import { c as AppToolContext, f as AppToolName, d as AppToolDefinition } from './types-CBRyqijY.js';
-import { a as ToolHeaderNames } from './auth-_FU8w01b.js';
+import { a as AppToolContext, b as AppToolName, c as AppToolDefinition } from './types-BCxK0wyS.js';
+import { T as ToolHeaderNames } from './auth-anc7mv2W.js';
 
 /** Default route path each app tool is served at. A product mounts its routes
  *  at these paths (or supplies its own via {@link BuildMcpServerOptions.paths}). */

package/dist/{mcp-rpc-BfUOsalw.d.ts → mcp-rpc-CzU5LWWT.d.ts}

@@ -55,4 +55,4 @@ interface CreateMcpToolHandlerOptions<TEnv = Record<string, never>> {
  */
 declare function createMcpToolHandler<TEnv = Record<string, never>>(opts: CreateMcpToolHandlerOptions<TEnv>): (request: Request) => Promise<Response>;
 
-export { type CreateMcpToolHandlerOptions as C, MCP_PROTOCOL_VERSIONS as M, type McpProtocolVersion as a, type McpServerInfo as b, type McpToolDefinition as c, createMcpToolHandler as d };
+export { type CreateMcpToolHandlerOptions as C, MCP_PROTOCOL_VERSIONS as M, type McpToolDefinition as a, type McpProtocolVersion as b, type McpServerInfo as c, createMcpToolHandler as d };