@tangle-network/agent-app 0.14.0 → 0.16.0

package/dist/runtime/index.d.ts

@@ -1,7 +1,11 @@
+import * as _tangle_network_agent_runtime from '@tangle-network/agent-runtime';
+import { ToolLoopMessage, ToolLoopResult, StreamToolLoopYield, ToolLoopCall } from '@tangle-network/agent-runtime';
+export { RunToolLoopOptions as AppToolLoopOptions, ToolLoopAssistantToolCall as LoopAssistantToolCall, ToolLoopMessage as LoopMessage, ToolLoopCall as LoopToolCall, StreamToolLoopOptions as StreamAppToolLoopOptions, StreamToolLoopYield as StreamLoopYield, ToolLoopEvent, ToolLoopResult, ToolLoopStopReason, runToolLoop as runAppToolLoop, streamToolLoop as streamAppToolLoop } from '@tangle-network/agent-runtime';
 export { C as CatalogModel, M as ModelCatalog, R as RouterModel, _ as __resetCatalogCache, b as buildCatalog, f as fetchModelCatalog, n as normalizeModelId } from '../model-catalog-BEAEVDaa.js';
 export { C as CreateTangleRouterModelConfigOptions, D as DEFAULT_TANGLE_BILLING_ENFORCEMENT_ENV_VAR, a as DEFAULT_TANGLE_ROUTER_BASE_URL, R as ResolveModelOptions, b as ResolveUserTangleExecutionKeyForUserOptions, c as ResolveUserTangleExecutionKeyOptions, d as ResolvedTangleExecutionKey, T as TangleBillingEnforcementOptions, e as TangleExecutionEnvironment, f as TangleExecutionKeyError, g as TangleExecutionKeyErrorCode, h as TangleExecutionKeyHttpError, i as TangleExecutionKeySource, j as TangleModelConfig, k as createTangleRouterModelConfig, l as isTangleBillingEnforcementDisabled, m as isTangleExecutionKeyError, r as resolveTangleExecutionEnvironment, n as resolveTangleModelConfig, o as resolveUserTangleExecutionKey, p as resolveUserTangleExecutionKeyForUser, t as tangleExecutionKeyHttpError } from '../model-CKzniMMr.js';
-import { b as AppToolContext, e as AppToolProducedEvent, f as AppToolTaxonomy, c as AppToolHandlers, d as AppToolOutcome } from '../types-By4B3K37.js';
-import { a as AppToolMcpServer } from '../mcp-CIupfjxV.js';
+import { b as AppToolContext, e as AppToolProducedEvent, f as AppToolTaxonomy, c as AppToolHandlers, d as AppToolOutcome } from '../types-2rOJo8Hc.js';
+import { CertifiedProfile } from '@tangle-network/agent-runtime/intelligence';
+import { a as AppToolMcpServer } from '../mcp-eZCmkgCF.js';
 
 /**
  * OpenAI-compatible stream → `LoopEvent` adapter, for NON-sandbox copilots.
@@ -75,7 +79,7 @@ interface OpenAICompatStreamTurnOptions {
  *   const cfg = resolveTangleModelConfig()                 // or { baseUrl, apiKey, model }
  *   streamAppToolLoop({ streamTurn: createOpenAICompatStreamTurn({ ...cfg, tools }), executeToolCall, ... })
  */
-declare function createOpenAICompatStreamTurn(opts: OpenAICompatStreamTurnOptions): (messages: LoopMessage[]) => AsyncIterable<LoopEvent>;
+declare function createOpenAICompatStreamTurn(opts: OpenAICompatStreamTurnOptions): (messages: ToolLoopMessage[]) => AsyncIterable<LoopEvent>;
 
 /**
  * `createAgentRuntime` — the in-process agent core, assembled.
@@ -120,9 +124,28 @@ interface AgentRuntimeModelConfig {
     /** Extra request-body fields (e.g. `max_tokens`, a `reasoning` block). */
     extraBody?: Record<string, unknown>;
 }
+/** The agent's resolved profile surfaces for one turn — the things a delivered
+ *  / certified `AgentProfile` can change. Profile-WIDE on purpose: certified
+ *  delivery folds prompt-surface + skills into `systemPrompt` AND can add
+ *  certified `tool` artifacts to `extraTools` (the model's advertised tools is
+ *  rebuilt when these change). MCP servers / memory / RAG that materialize as
+ *  files or servers deliver through the sandbox-provisioning seam, not here. */
+interface ResolvedAgentProfile {
+    systemPrompt: string;
+    extraTools: unknown[];
+}
 interface CreateAgentRuntimeOptions {
     /** The model endpoint the turns stream from. */
     model: AgentRuntimeModelConfig;
+    /**
+     * Optional transform applied to the resolved profile surfaces each turn —
+     * the seam for certified-artifact delivery (`createCertifiedDelivery`). It is
+     * profile-WIDE (not prompt-only): it returns the effective `systemPrompt` +
+     * advertised `extraTools`. Kept generic + injected so this substrate-free core
+     * never imports `@tangle-network/agent-runtime`. Fail-closed by contract: an
+     * impl that can't reach the plane returns the base surfaces unchanged.
+     */
+    composeProfile?: (base: ResolvedAgentProfile) => ResolvedAgentProfile | Promise<ResolvedAgentProfile>;
     /** The product's proposal taxonomy — advertises `submit_proposal`'s `type`
      *  enum to the model and labels the regulated subset on the result. */
     taxonomy: AppToolTaxonomy;
@@ -138,7 +161,7 @@ interface CreateAgentRuntimeOptions {
     extraTools?: unknown[];
     /** Execute a tool that is NOT one of the four app tools (e.g. an integration
      *  action). Only consulted for names {@link isOtherExecutableTool} accepts. */
-    executeOtherTool?: (call: LoopToolCall, ctx: AppToolContext) => Promise<AppToolOutcome>;
+    executeOtherTool?: (call: ToolLoopCall, ctx: AppToolContext) => Promise<AppToolOutcome>;
     /** Which non-app tool names are executable here. Required if {@link executeOtherTool} is set. */
     isOtherExecutableTool?: (toolName: string) => boolean;
 }
@@ -161,7 +184,7 @@ interface AgentRuntime {
     run(userMessage: string, turn: AgentTurnOptions): Promise<ToolLoopResult>;
     /** Stream the bounded tool loop: yields each raw model event and each executed
      *  tool result as it happens (for SSE re-emission + telemetry). */
-    stream(userMessage: string, turn: AgentTurnOptions): AsyncGenerator<StreamLoopYield<LoopEvent>, void, unknown>;
+    stream(userMessage: string, turn: AgentTurnOptions): AsyncGenerator<StreamToolLoopYield<LoopEvent>, void, unknown>;
 }
 /**
  * Create an in-process agent runtime for one agent. See the module doc for the
@@ -171,6 +194,61 @@ interface AgentRuntime {
  */
 declare function createAgentRuntime(opts: CreateAgentRuntimeOptions): AgentRuntime;
 
+/**
+ * `createCertifiedDelivery` — the delivery truck for Tangle Intelligence.
+ *
+ * Pulls a tenant's CERTIFIED `AgentProfile` from the deployed plane
+ * (`GET /v1/profiles/:target/composed`) and applies it to the agent's resolved
+ * surfaces each turn, so an approved improvement reaches the running agent with
+ * NO redeploy. This is the `composeProfile` transform `createAgentRuntime`
+ * accepts — opt-in per product, fail-closed, cached + refreshed.
+ *
+ * Profile-WIDE by design (not prompt-only): the composed profile carries every
+ * promoted artifact type keyed by kind. What's folded where:
+ *   - `prompt-surface` + `skill` → the system prompt (via `composeCertifiedPrompt`).
+ *   - `tool` artifacts that carry an OpenAI tool definition → `extraTools`
+ *     (advertised to the model; the matching executor is supplied by the product
+ *     via `executeOtherTool`). Until a `tool` artifact carries a runnable def,
+ *     it is surfaced (see `current()`) but not advertised — advertising a tool
+ *     with no executor would make the model call into a dead end.
+ *   - `mcp` / `memory` / `rag` artifacts materialize as servers/files and deliver
+ *     through the SANDBOX-provisioning seam, not this in-process one. The full
+ *     certified profile is exposed via `current()` so that seam can consume it.
+ *
+ * Substrate boundary: THIS module imports `@tangle-network/agent-runtime`; the
+ * `createAgentRuntime` core does not (it only consumes the generic transform).
+ */
+
+interface CertifiedDeliveryConfig {
+    /** The tenant target whose certified artifacts to deliver (the agent id). */
+    target: string;
+    /** Bearer for the plane. Reads `TANGLE_API_KEY` when omitted. */
+    apiKey?: string;
+    /** Plane base URL. Reads `TANGLE_INTELLIGENCE_URL` then the public plane. */
+    baseUrl?: string;
+    /** Min interval between certified-profile pulls. Default 5m. */
+    refreshMs?: number;
+    /** fetch impl (tests / non-global-fetch runtimes). */
+    fetchImpl?: typeof fetch;
+}
+interface CertifiedDelivery {
+    /** The `composeProfile` transform to pass to `createAgentRuntime`. Applies the
+     *  cached certified profile to the base surfaces; refreshes on the cadence. */
+    composeProfile(base: ResolvedAgentProfile): Promise<ResolvedAgentProfile>;
+    /** Force a pull now (ignores the refresh window). Best-effort. */
+    refresh(): Promise<void>;
+    /** The certified profile currently in effect (null = none promoted / pull
+     *  failed). Lets the sandbox-provisioning seam deliver the file/server
+     *  artifact types this in-process seam doesn't. */
+    current(): CertifiedProfile | null;
+}
+/**
+ * Build a certified-delivery transform for one agent target. Fail-closed: a pull
+ * error or 404 keeps the last-known certified profile (or null), and the agent
+ * runs on its base surfaces — it never breaks because Intelligence is down.
+ */
+declare function createCertifiedDelivery(config: CertifiedDeliveryConfig): CertifiedDelivery;
+
 /**
  * Surface-scoped profile overlay — the seam letting any product page (a
  * sequence editor, a brief composer, a dataset view) add MCP servers, a prompt
@@ -277,46 +355,17 @@ interface SurfaceMergeBase {
  */
 declare function mergeSurfaceOverlay<TBase extends SurfaceMergeBase>(base: TBase, overlay: SurfaceOverlay): TBase & SurfaceMergeBase;
 
-interface LoopToolCall {
-    toolCallId?: string;
-    toolName: string;
-    args: Record<string, unknown>;
-}
-/** One OpenAI-shaped tool-call entry on an assistant message. */
-interface LoopAssistantToolCall {
-    id: string;
-    type: 'function';
-    function: {
-        name: string;
-        arguments: string;
-    };
-}
 /**
- * A message in the running conversation the loop sends to `streamTurn`.
- *
- * The base `{ role, content }` covers `system` / `user` / plain `assistant`
- * turns. Two optional fields carry the OpenAI function-calling contract so the
- * model reads its own tool use back correctly instead of re-issuing it:
+ * Events the app's OpenAI-compat stream adapter ({@link toLoopEvents}) yields.
  *
- *   - an assistant turn that emitted tool calls carries `tool_calls`, and its
- *     `content` is `null` when the turn was tool-only;
- *   - each tool result is its own `{ role: 'tool', tool_call_id, content }`
- *     message keyed to the call that produced it.
- *
- * Widening is additive: a `streamTurn` that reads only `role` + `content` still
- * works; one that forwards the whole message to an OpenAI-compatible endpoint
- * now gets correct tool history. */
-interface LoopMessage {
-    role: string;
-    content: string | null;
-    tool_calls?: LoopAssistantToolCall[];
-    tool_call_id?: string;
-}
-/** Events a turn stream yields. `text` accumulates into the final answer;
- *  `tool_call` is collected for dispatch; `reasoning` and `usage` pass through
- *  for UIs that render thinking sections and per-message token/cost metrics.
- *  Extra event types pass through untouched (the caller re-emits them to its
- *  own UI stream). */
+ * This is the app's own `Raw` event type for the streaming loop — the canonical
+ * `streamToolLoop<Raw>` is generic over it. It widens the substrate's
+ * tool-loop event with `reasoning` (DeepSeek/router `reasoning_content` /
+ * `thinking` deltas, rendered as thinking sections) and `usage` (per-message
+ * token accounting) — neither belongs in the substrate's loop contract, so they
+ * stay here. The adapter maps each into the `streamTurn` seam; `text` and
+ * `tool_call` drive the loop, `reasoning` / `usage` pass through to the UI.
+ */
 type LoopEvent = {
     type: 'text';
     text: string;
@@ -325,7 +374,7 @@ type LoopEvent = {
     text: string;
 } | {
     type: 'tool_call';
-    call: LoopToolCall;
+    call: _tangle_network_agent_runtime.ToolLoopCall;
 } | {
     type: 'usage';
     usage: {
@@ -336,121 +385,5 @@ type LoopEvent = {
     type: 'other';
     event: unknown;
 };
-/** Why the loop stopped. `completed` = model finished naturally; `stuck-loop` =
- *  ≥3 consecutive identical tool calls (same tool + args); `backstop` = hit the
- *  runaway-backstop cap (200 by default); `deadline` = wall-clock deadlineMs
- *  exceeded; `budget` = maxCostUsd exhausted. Non-`completed` stops are infra /
- *  resource outcomes — eval scoring must distinguish them from capability failure. */
-type ToolLoopStopReason = 'completed' | 'stuck-loop' | 'backstop' | 'deadline' | 'budget';
-interface ToolLoopResult {
-    /** The model's final text across the loop. */
-    finalText: string;
-    /** Every tool call executed, with its outcome, in order. */
-    toolResults: Array<{
-        call: LoopToolCall;
-        label: string;
-        outcome: AppToolOutcome;
-    }>;
-    /** Number of model turns run (1 + tool-driven re-runs). */
-    turns: number;
-    /** Why the loop stopped. */
-    stopReason: ToolLoopStopReason;
-    /** @deprecated Use `stopReason !== 'completed'` instead. */
-    cappedOut: boolean;
-}
-interface AppToolLoopOptions {
-    systemPrompt: string;
-    userMessage: string;
-    priorMessages?: Array<{
-        role: string;
-        content: string;
-    }>;
-    /** Stream one model turn over the running message list. The app wraps its
-     *  backend here. Messages follow {@link LoopMessage}: a tool-calling assistant
-     *  turn carries `tool_calls`, and each tool result is a `role: 'tool'` message.
-     *  A backend that reads only `role` + `content` is unaffected. */
-    streamTurn: (messages: LoopMessage[]) => AsyncIterable<LoopEvent>;
-    /** Execute one tool call. The app routes to its integration executor / app-tool
-     *  executor and returns the outcome. */
-    executeToolCall: (call: LoopToolCall) => Promise<AppToolOutcome>;
-    /** Which emitted tool names are executable (others are ignored — e.g. a UI-only
-     *  tool the app renders but doesn't run here). */
-    isExecutableTool: (toolName: string) => boolean;
-    /** Runaway-backstop cap. Default 200 — set far above any legitimate workflow.
-     *  For per-workflow limits use `maxCostUsd` or `deadlineMs` instead. */
-    maxToolTurns?: number;
-    /** Wall-clock deadline in ms since epoch (Date.now()-based). When exceeded the
-     *  loop stops with stopReason `deadline`. */
-    deadlineMs?: number;
-    /** Maximum total cost in USD. Requires `costOf` to meter each tool call. */
-    maxCostUsd?: number;
-    /** Return the USD cost of one outcome. Required for `maxCostUsd` to work. */
-    costOf?: (call: LoopToolCall, outcome: AppToolOutcome) => number;
-    /** Render one tool outcome as the `content` of its `role: 'tool'` message.
-     *  Default is a compact `<label> → ok/failed: …`. */
-    renderResult?: (label: string, outcome: AppToolOutcome) => string;
-    /** Map a tool call to the label its result is keyed under (default: toolName). */
-    labelFor?: (call: LoopToolCall) => string;
-}
-/**
- * Run the bounded tool loop and return the final text + every executed tool
- * outcome. Yields nothing — it's an awaitable driver; callers that need to
- * re-emit events to a UI stream should do so inside `streamTurn`. (A streaming
- * variant can wrap this later; keeping the core awaitable makes it trivially
- * testable.)
- */
-declare function runAppToolLoop(opts: AppToolLoopOptions): Promise<ToolLoopResult>;
-type StreamLoopYield<Raw> = {
-    kind: 'event';
-    event: Raw;
-} | {
-    kind: 'tool_result';
-    toolName: string;
-    toolCallId?: string;
-    label: string;
-    outcome: AppToolOutcome;
-} | {
-    kind: 'capped';
-    pending: number;
-    stopReason: Exclude<ToolLoopStopReason, 'completed'>;
-};
-interface StreamAppToolLoopOptions<Raw> {
-    systemPrompt: string;
-    userMessage: string;
-    priorMessages?: Array<{
-        role: string;
-        content: string;
-    }>;
-    /** Stream one model turn (the app wraps its backend / runAgentTaskStream).
-     *  Messages follow {@link LoopMessage}: a tool-calling assistant turn carries
-     *  `tool_calls`, and each tool result is a `role: 'tool'` message. */
-    streamTurn: (messages: LoopMessage[]) => AsyncIterable<Raw>;
-    /** Text contribution of a raw event, '' if none — used to record the
-     *  assistant's turn so the next turn has its context. */
-    extractText: (event: Raw) => string;
-    /** The tool call a raw event represents, or null. */
-    extractToolCall: (event: Raw) => LoopToolCall | null;
-    /** Which tool names are executable here (others pass through, unexecuted). */
-    isExecutableTool: (toolName: string) => boolean;
-    /** Execute one call — the app routes to its integration / app-tool executor. */
-    executeToolCall: (call: LoopToolCall) => Promise<AppToolOutcome>;
-    /** Runaway-backstop cap. Default 200 — set far above any legitimate workflow. */
-    maxToolTurns?: number;
-    /** Wall-clock deadline in ms since epoch (Date.now()-based). */
-    deadlineMs?: number;
-    /** Maximum total cost in USD. Requires `costOf` to meter each tool call. */
-    maxCostUsd?: number;
-    /** Return the USD cost of one outcome. Required for `maxCostUsd` to work. */
-    costOf?: (call: LoopToolCall, outcome: AppToolOutcome) => number;
-    renderResult?: (label: string, outcome: AppToolOutcome) => string;
-    labelFor?: (call: LoopToolCall) => string;
-}
-/**
- * The streaming bounded tool loop. Yields `event` for each raw turn event and
- * `tool_result` for each executed tool; emits a single `capped` (with stopReason)
- * when it stops for any non-completed reason. The app drives telemetry + UI
- * emission off the yielded items.
- */
-declare function streamAppToolLoop<Raw>(opts: StreamAppToolLoopOptions<Raw>): AsyncGenerator<StreamLoopYield<Raw>, void, unknown>;
 
-export { type AgentRuntime, type AgentRuntimeModelConfig, type AgentTurnOptions, type AnySurfaceKind, type AppToolLoopOptions, type CreateAgentRuntimeOptions, type LoopAssistantToolCall, type LoopEvent, type LoopMessage, type LoopToolCall, type OpenAICompatStreamTurnOptions, type OpenAIStreamChunk, type StreamAppToolLoopOptions, type StreamLoopYield, type SurfaceKindDefinition, type SurfaceMcpServer, type SurfaceMergeBase, type SurfaceOverlay, type SurfacePermissionValue, type SurfaceRegistry, type ToolLoopResult, type ToolLoopStopReason, createAgentRuntime, createOpenAICompatStreamTurn, createSurfaceRegistry, defineSurfaceKind, mergeSurfaceOverlay, runAppToolLoop, streamAppToolLoop, toLoopEvents };
+export { type AgentRuntime, type AgentRuntimeModelConfig, type AgentTurnOptions, type AnySurfaceKind, type CertifiedDelivery, type CertifiedDeliveryConfig, type CreateAgentRuntimeOptions, type LoopEvent, type OpenAICompatStreamTurnOptions, type OpenAIStreamChunk, type ResolvedAgentProfile, type SurfaceKindDefinition, type SurfaceMcpServer, type SurfaceMergeBase, type SurfaceOverlay, type SurfacePermissionValue, type SurfaceRegistry, createAgentRuntime, createCertifiedDelivery, createOpenAICompatStreamTurn, createSurfaceRegistry, defineSurfaceKind, mergeSurfaceOverlay, toLoopEvents };

package/dist/runtime/index.js

@@ -2,16 +2,17 @@ import {
   __resetCatalogCache,
   buildCatalog,
   createAgentRuntime,
+  createCertifiedDelivery,
   createOpenAICompatStreamTurn,
   createSurfaceRegistry,
   defineSurfaceKind,
   fetchModelCatalog,
   mergeSurfaceOverlay,
   normalizeModelId,
-  runAppToolLoop,
-  streamAppToolLoop,
+  runToolLoop,
+  streamToolLoop,
   toLoopEvents
-} from "../chunk-ETX4O4BB.js";
+} from "../chunk-LUE4HO5C.js";
 import {
   DEFAULT_TANGLE_BILLING_ENFORCEMENT_ENV_VAR,
   DEFAULT_TANGLE_ROUTER_BASE_URL,
@@ -25,7 +26,7 @@ import {
   resolveUserTangleExecutionKeyForUser,
   tangleExecutionKeyHttpError
 } from "../chunk-EHPK7GKR.js";
-import "../chunk-QAQBR6KQ.js";
+import "../chunk-JZZ6AWF4.js";
 export {
   DEFAULT_TANGLE_BILLING_ENFORCEMENT_ENV_VAR,
   DEFAULT_TANGLE_ROUTER_BASE_URL,
@@ -33,6 +34,7 @@ export {
   __resetCatalogCache,
   buildCatalog,
   createAgentRuntime,
+  createCertifiedDelivery,
   createOpenAICompatStreamTurn,
   createSurfaceRegistry,
   createTangleRouterModelConfig,
@@ -46,8 +48,8 @@ export {
   resolveTangleModelConfig,
   resolveUserTangleExecutionKey,
   resolveUserTangleExecutionKeyForUser,
-  runAppToolLoop,
-  streamAppToolLoop,
+  runToolLoop as runAppToolLoop,
+  streamToolLoop as streamAppToolLoop,
   tangleExecutionKeyHttpError,
   toLoopEvents
 };

package/dist/sequences/index.d.ts

@@ -1,8 +1,8 @@
 import { j as SequenceMediaKind, o as SequenceTimeline, r as TimelineInterval, m as SequenceStore } from '../store-gckrNq-g.js';
 export { M as MIN_SEQUENCE_CLIP_FRAMES, N as NewSequenceClip, a as NewSequenceDecision, b as NewSequenceTrack, S as SequenceClip, c as SequenceClipMedia, d as SequenceClipPatch, e as SequenceDecision, f as SequenceExportFormat, g as SequenceExportRecord, h as SequenceExportStatus, i as SequenceFrameSnapshot, k as SequenceMeta, l as SequenceStatus, n as SequenceStoreScope, p as SequenceTrack, q as SequenceTrackKind, T as TimelineClipBounds, s as assertClipFitsSequence, t as chooseCaptionPlacement, u as clampClipDuration, v as clampClipStart, w as formatSeconds, x as formatTimecode, y as framesToSeconds, z as secondsToFrames, A as snapshotFrame, B as trackIntervals } from '../store-gckrNq-g.js';
 export { A as AddCaptionOperation, C as CaptionTargetResolution, a as CreateTrackOperation, D as DeleteClipOperation, E as ExtendSequenceOperation, M as MoveClipOperation, P as PlaceClipOperation, Q as QueueExportOperation, S as SEQUENCE_OPERATION_TYPES, b as SequenceApplyResult, c as SequenceOperation, d as SequenceOperationContext, e as SequenceOperationType, f as SequencePlan, g as SetClipDisabledOperation, h as SetClipTextOperation, i as SplitClipOperation, T as TrimClipOperation, j as applySequenceOperation, k as applySequenceOperations, l as assertSequenceMediaUrl, m as captionTrackNameForLanguage, n as lastClipEndFrame, p as parseSequenceOperations, r as resolveCaptionPlacement, o as resolveCaptionTarget, q as resolvePlaceClipTrack, v as validateAddCaption, s as validateCreateTrack, t as validateDeleteClip, u as validateExtendSequence, w as validateMoveClip, x as validatePlaceClip, y as validateQueueExport, z as validateSequenceOperation, B as validateSequenceOperations, F as validateSetClipDisabled, G as validateSetClipText, H as validateSplitClip, I as validateTrimClip } from '../apply-Cp8c3K9D.js';
-import { f as ToolHeaderNames, a as AppToolMcpServer } from '../mcp-CIupfjxV.js';
-import { b as AppToolContext } from '../types-By4B3K37.js';
+import { f as ToolHeaderNames, a as AppToolMcpServer } from '../mcp-eZCmkgCF.js';
+import { b as AppToolContext } from '../types-2rOJo8Hc.js';
 
 /**
  * Pure interchange-format builders over `SequenceTimeline` — SRT, WebVTT,

package/dist/tools/index.d.ts

@@ -1,7 +1,7 @@
-import { b as AppToolName, f as ToolHeaderNames } from '../mcp-CIupfjxV.js';
-export { A as APP_TOOL_NAMES, a as AppToolMcpServer, c as AuthenticateOptions, B as BuildHttpMcpServerOptions, d as BuildMcpServerOptions, D as DEFAULT_APP_TOOL_PATHS, e as DEFAULT_HEADER_NAMES, O as OpenAIFunctionTool, T as ToolAuthResult, g as authenticateToolRequest, h as buildAppToolMcpServer, i as buildAppToolOpenAITools, j as buildHttpMcpServer, k as isAppToolName, r as readToolArgs } from '../mcp-CIupfjxV.js';
-import { f as AppToolTaxonomy, c as AppToolHandlers, b as AppToolContext, e as AppToolProducedEvent, d as AppToolOutcome } from '../types-By4B3K37.js';
-export { A as AddCitationArgs, a as AddCitationResult, R as RenderUiArgs, g as RenderUiResult, S as ScheduleFollowupArgs, h as ScheduleFollowupResult, i as SubmitProposalArgs, j as SubmitProposalResult } from '../types-By4B3K37.js';
+import { b as AppToolName, f as ToolHeaderNames } from '../mcp-eZCmkgCF.js';
+export { A as APP_TOOL_NAMES, a as AppToolMcpServer, c as AuthenticateOptions, B as BuildHttpMcpServerOptions, d as BuildMcpServerOptions, D as DEFAULT_APP_TOOL_PATHS, e as DEFAULT_HEADER_NAMES, O as OpenAIFunctionTool, T as ToolAuthResult, g as authenticateToolRequest, h as buildAppToolMcpServer, i as buildAppToolOpenAITools, j as buildHttpMcpServer, k as isAppToolName, r as readToolArgs } from '../mcp-eZCmkgCF.js';
+import { f as AppToolTaxonomy, c as AppToolHandlers, b as AppToolContext, e as AppToolProducedEvent, d as AppToolOutcome } from '../types-2rOJo8Hc.js';
+export { A as AddCitationArgs, a as AddCitationResult, R as RenderUiArgs, g as RenderUiResult, S as ScheduleFollowupArgs, h as ScheduleFollowupResult, i as SubmitProposalArgs, j as SubmitProposalResult } from '../types-2rOJo8Hc.js';
 export { C as CreateMcpToolHandlerOptions, M as MCP_PROTOCOL_VERSIONS, a as McpProtocolVersion, b as McpServerInfo, c as McpToolDefinition, d as createMcpToolHandler } from '../mcp-rpc-DLw_r9PQ.js';
 
 /** A correctable bad-input error a tool handler throws; the HTTP layer maps it

package/dist/tools/index.js

@@ -6,7 +6,7 @@ import {
   restrictTaxonomy,
   verifyCapabilityToken,
   verifyExpiringCapabilityToken
-} from "../chunk-SSX2A6XX.js";
+} from "../chunk-MH6AVXQ7.js";
 import {
   DEFAULT_APP_TOOL_PATHS,
   DEFAULT_HEADER_NAMES,
@@ -25,7 +25,7 @@ import {
   dispatchAppTool,
   isAppToolName,
   outcomeStatus
-} from "../chunk-QAQBR6KQ.js";
+} from "../chunk-JZZ6AWF4.js";
 export {
   APP_TOOL_NAMES,
   DEFAULT_APP_TOOL_PATHS,

package/dist/{types-By4B3K37.d.ts → types-2rOJo8Hc.d.ts}

@@ -110,14 +110,17 @@ type AppToolProducedEvent = {
     proposalId: string;
     title: string;
     status: 'pending' | 'executed';
+    content?: string;
 } | {
     type: 'artifact';
     path: string;
     content: string;
 };
-/** Outcome of one tool dispatch — structurally compatible with the integration
- *  tool-outcome union the agent-runtime chat loop already folds into a
- *  tool_result. */
+/** Outcome of one tool dispatch — structurally identical to the agent-runtime
+ *  tool-loop's `ToolCallOutcome`, so a dispatched outcome folds straight into
+ *  the loop's `role: 'tool'` result message. Defined here (not imported) to keep
+ *  the `tools/` module substrate-free: it depends only on Web `Request`/
+ *  `Response`, never on the agent runtime. */
 type AppToolOutcome = {
     ok: true;
     result: unknown;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/agent-app",
-  "version": "0.14.0",
+  "version": "0.16.0",
   "packageManager": "pnpm@10.33.4",
   "description": "Application-shell framework for Tangle agent products: a bounded tool loop, the structured agent\u2192app tool side channel, integration-hub client, per-workspace billing, and crypto \u2014 composed over the Tangle agent substrate through typed seams.",
   "keywords": [
@@ -192,8 +192,9 @@
     "typecheck": "tsc --noEmit"
   },
   "devDependencies": {
-    "@tangle-network/agent-eval": "^0.82.0",
+    "@tangle-network/agent-eval": "^0.83.0",
     "@tangle-network/agent-integrations": "^0.32.0",
+    "@tangle-network/agent-runtime": "^0.52.0",
     "@tangle-network/agent-knowledge": "^1.5.2",
     "@testing-library/dom": "^10.4.1",
     "@testing-library/react": "^16.3.2",
@@ -214,10 +215,10 @@
   },
   "peerDependencies": {
     "@huggingface/transformers": ">=3",
-    "@tangle-network/agent-eval": ">=0.82.0",
+    "@tangle-network/agent-eval": ">=0.83.0",
     "@tangle-network/agent-integrations": ">=0.32.0",
     "@tangle-network/agent-knowledge": ">=1.5.0",
-    "@tangle-network/agent-runtime": ">=0.21.0",
+    "@tangle-network/agent-runtime": ">=0.52.0",
     "drizzle-orm": ">=0.36",
     "react": ">=18",
     "konva": ">=9",

package/dist/DesignCanvasEditor-37LPJIIR.js

@@ -1,9 +0,0 @@
-import {
-  DesignCanvasEditor
-} from "./chunk-2Q73HGDI.js";
-import "./chunk-F5KTWRO7.js";
-import "./chunk-JZAJE3JL.js";
-export {
-  DesignCanvasEditor
-};
-//# sourceMappingURL=DesignCanvasEditor-37LPJIIR.js.map