@tangle-network/agent-app 0.7.0 → 0.7.2

package/dist/missions/index.js

@@ -0,0 +1,45 @@
+import {
+  DEFAULT_MISSION_STEP_KINDS,
+  MISSION_CONTROL_CHANNEL_ID,
+  MissionConcurrencyError,
+  RetryableStepError,
+  applyMissionEvent,
+  asMissionStreamEvent,
+  budgetGateProposalId,
+  buildAgentMissionPlan,
+  createInMemoryMissionStore,
+  createMissionEngine,
+  createMissionService,
+  isMissionStopRequested,
+  isMissionTerminal,
+  mergeMissionState,
+  noopEventSink,
+  parseMissionBlocks,
+  parseSessionStreamEnvelope,
+  reduceMissionEvents,
+  stepGateProposalId,
+  volumeGateProposalId
+} from "../chunk-UIWB2F6N.js";
+export {
+  DEFAULT_MISSION_STEP_KINDS,
+  MISSION_CONTROL_CHANNEL_ID,
+  MissionConcurrencyError,
+  RetryableStepError,
+  applyMissionEvent,
+  asMissionStreamEvent,
+  budgetGateProposalId,
+  buildAgentMissionPlan,
+  createInMemoryMissionStore,
+  createMissionEngine,
+  createMissionService,
+  isMissionStopRequested,
+  isMissionTerminal,
+  mergeMissionState,
+  noopEventSink,
+  parseMissionBlocks,
+  parseSessionStreamEnvelope,
+  reduceMissionEvents,
+  stepGateProposalId,
+  volumeGateProposalId
+};
+//# sourceMappingURL=index.js.map

package/dist/missions/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/runtime/index.d.ts

@@ -129,7 +129,8 @@ interface CreateAgentRuntimeOptions {
     handlers: AppToolHandlers;
     /** Default agent identity / system prompt. A turn may override it. */
     systemPrompt: string;
-    /** Max tool-driven re-runs per turn. Default 8. */
+    /** Runaway-backstop cap. Default 200 — set far above any legitimate workflow.
+     *  For per-workflow limits use `deadlineMs` or `maxCostUsd` on the loop options. */
     maxToolTurns?: number;
     /** Extra OpenAI tool definitions advertised ALONGSIDE the four app tools
      *  (e.g. `integration_invoke`). Pair with {@link executeOtherTool}. */
@@ -228,6 +229,12 @@ 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;
@@ -239,7 +246,9 @@ interface ToolLoopResult {
     }>;
     /** Number of model turns run (1 + tool-driven re-runs). */
     turns: number;
-    /** True when the loop stopped because it hit `maxToolTurns` with calls still pending. */
+    /** Why the loop stopped. */
+    stopReason: ToolLoopStopReason;
+    /** @deprecated Use `stopReason !== 'completed'` instead. */
     cappedOut: boolean;
 }
 interface AppToolLoopOptions {
@@ -260,8 +269,16 @@ interface AppToolLoopOptions {
     /** 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;
-    /** Max tool-driven re-runs. Default 8. */
+    /** 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;
@@ -288,6 +305,7 @@ type StreamLoopYield<Raw> = {
 } | {
     kind: 'capped';
     pending: number;
+    stopReason: Exclude<ToolLoopStopReason, 'completed'>;
 };
 interface StreamAppToolLoopOptions<Raw> {
     systemPrompt: string;
@@ -309,16 +327,23 @@ interface StreamAppToolLoopOptions<Raw> {
     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` when it stops at
- * the turn limit with calls still pending. The app drives telemetry + UI
+ * `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 AppToolLoopOptions, type CreateAgentRuntimeOptions, type LoopAssistantToolCall, type LoopEvent, type LoopMessage, type LoopToolCall, type OpenAICompatStreamTurnOptions, type OpenAIStreamChunk, type StreamAppToolLoopOptions, type StreamLoopYield, type ToolLoopResult, createAgentRuntime, createOpenAICompatStreamTurn, runAppToolLoop, streamAppToolLoop, toLoopEvents };
+export { type AgentRuntime, type AgentRuntimeModelConfig, type AgentTurnOptions, type AppToolLoopOptions, type CreateAgentRuntimeOptions, type LoopAssistantToolCall, type LoopEvent, type LoopMessage, type LoopToolCall, type OpenAICompatStreamTurnOptions, type OpenAIStreamChunk, type StreamAppToolLoopOptions, type StreamLoopYield, type ToolLoopResult, type ToolLoopStopReason, createAgentRuntime, createOpenAICompatStreamTurn, runAppToolLoop, streamAppToolLoop, toLoopEvents };

package/dist/runtime/index.js

@@ -8,7 +8,7 @@ import {
   runAppToolLoop,
   streamAppToolLoop,
   toLoopEvents
-} from "../chunk-TH2AOJJM.js";
+} from "../chunk-4YTWB5MG.js";
 import {
   DEFAULT_TANGLE_BILLING_ENFORCEMENT_ENV_VAR,
   DEFAULT_TANGLE_ROUTER_BASE_URL,

package/dist/web-react/index.d.ts

@@ -2,6 +2,94 @@ import * as react from 'react';
 import { ReactNode } from 'react';
 import { C as CatalogModel } from '../model-catalog-BEAEVDaa.js';
 
+/**
+ * Client-side chat-stream consumption — the NDJSON parse loop every agent
+ * app's chat UI hand-rolls (and breaks). Normalizes the three line shapes the
+ * agent-app chat routes emit:
+ *
+ *   {kind:'event', event:{type:'text'|'reasoning'|'tool_call'|'usage', ...}}
+ *   {kind:'tool_result', toolCallId, toolName, label, outcome}
+ *   {type:'turn'|'metadata'|'error'|'turn_status', ...}          (route-level)
+ *
+ * Replayed lines carry an extra `seq` — transparently ignored. Works for
+ * router-backed and sandbox-backed chats alike: anything producing these
+ * lines (live pump, queued follow, resume replay) feeds the same callbacks.
+ */
+interface ChatStreamToolCall {
+    toolCallId?: string;
+    toolName: string;
+    args: Record<string, unknown>;
+}
+interface ChatStreamToolResult {
+    toolCallId?: string;
+    toolName?: string;
+    label?: string;
+    outcome: {
+        ok: boolean;
+        result?: unknown;
+        code?: string;
+        message?: string;
+    };
+}
+interface ChatStreamCallbacks {
+    onTurnId?: (turnId: string) => void;
+    onText?: (delta: string) => void;
+    onReasoning?: (delta: string) => void;
+    onToolCall?: (call: ChatStreamToolCall) => void;
+    onToolResult?: (result: ChatStreamToolResult) => void;
+    onUsage?: (usage: {
+        promptTokens: number;
+        completionTokens: number;
+    }) => void;
+    onMetadata?: (data: Record<string, unknown>) => void;
+    /** A loop-level error event (the turn failed server-side). */
+    onErrorEvent?: (message: string) => void;
+}
+interface ConsumeChatStreamResult {
+    turnId: string | null;
+    /** True when any text/reasoning/tool activity was received. */
+    receivedContent: boolean;
+}
+/** Parse one NDJSON line into the callbacks. Exposed for tests. */
+declare function dispatchChatStreamLine(line: string, cb: ChatStreamCallbacks): {
+    turnId?: string;
+    receivedContent: boolean;
+};
+/** Drain one NDJSON body into the callbacks. Throws on transport failure
+ *  (caller decides whether to resume). */
+declare function consumeChatStream(body: ReadableStream<Uint8Array>, cb: ChatStreamCallbacks): Promise<ConsumeChatStreamResult>;
+interface StreamChatOptions {
+    /** Start the turn (POST the chat request); must return a streaming Response. */
+    start: () => Promise<Response>;
+    /** Re-attach to a turn after a transport drop (GET the resume route). */
+    resume?: (turnId: string, fromSeq: number) => Promise<Response>;
+    callbacks: ChatStreamCallbacks;
+    /** Called before a resume replays from 0 so the UI can reset accumulated
+     *  turn state (text, reasoning, tool chips). */
+    onResetForResume?: () => void;
+}
+/**
+ * Run one chat turn with automatic single-shot resume: if the transport drops
+ * mid-turn and the server announced a turnId, reset and replay the buffered
+ * turn. Server-side the turn keeps running either way (queued runner).
+ */
+declare function streamChatTurn(opts: StreamChatOptions): Promise<ConsumeChatStreamResult>;
+
+/**
+ * Provider brand marks — real logo path data (simple-icons / SVG Logos, both
+ * CC0) inlined so the picker shows actual provider identity instead of
+ * colored-initial monograms. Providers without a usable mark fall back to a
+ * tinted monogram chip. Aliases (z-ai/zai, moonshot/moonshotai, deepseek_ai)
+ * normalize to one entry.
+ */
+
+interface ProviderLogoProps {
+    provider?: string;
+    size?: number;
+}
+/** Real brand mark when we have one; tinted monogram otherwise. */
+declare function ProviderLogo({ provider, size }: ProviderLogoProps): ReactNode;
+
 interface ChatMessageMetrics {
     modelUsed?: string;
     promptTokens?: number;
@@ -114,4 +202,4 @@ interface ProposalApprovalHandlers {
  */
 declare function ChatMessages({ messages, models, renderMarkdown, renderExtras, userLabel, agentLabel, loading, approval, onToolCallClick, }: ChatMessagesProps): react.JSX.Element;
 
-export { type ChatMessageMetrics, ChatMessages, type ChatMessagesProps, type ChatToolCallInfo, type ChatUiMessage, EffortPicker, type EffortPickerProps, ModelPicker, type ModelPickerProps, type ProposalApprovalHandlers, RunDrillIn, type RunDrillInProps, type ToolRunRecord, type ToolRunStep, formatModelCost, formatTokensPerSecond, pendingApprovalOf };
+export { type ChatMessageMetrics, ChatMessages, type ChatMessagesProps, type ChatStreamCallbacks, type ChatStreamToolCall, type ChatStreamToolResult, type ChatToolCallInfo, type ChatUiMessage, type ConsumeChatStreamResult, EffortPicker, type EffortPickerProps, ModelPicker, type ModelPickerProps, type ProposalApprovalHandlers, ProviderLogo, type ProviderLogoProps, RunDrillIn, type RunDrillInProps, type StreamChatOptions, type ToolRunRecord, type ToolRunStep, consumeChatStream, dispatchChatStreamLine, formatModelCost, formatTokensPerSecond, pendingApprovalOf, streamChatTurn };