@tangle-network/agent-app 0.11.0 → 0.12.0

package/dist/{chunk-EYXTDVDY.js → chunk-SAOAAA3S.js}

@@ -1,6 +1,6 @@
 import {
   createWorkspaceKeyManager
-} from "./chunk-YS6A6G57.js";
+} from "./chunk-G3HCU7TA.js";
 import {
   createFieldCrypto
 } from "./chunk-TA5Q4I2K.js";
@@ -315,4 +315,4 @@ export {
   createPresetWorkspaceKeyStore,
   createPresetWorkspaceKeyManager
 };
-//# sourceMappingURL=chunk-EYXTDVDY.js.map
+//# sourceMappingURL=chunk-SAOAAA3S.js.map

package/dist/chunk-ZYBWGSAZ.js

@@ -0,0 +1,130 @@
+// src/sequences/model.ts
+var MIN_SEQUENCE_CLIP_FRAMES = 1;
+function secondsToFrames(seconds, fps) {
+  if (!Number.isFinite(seconds) || seconds < 0) throw new Error("seconds must be a non-negative finite number");
+  assertFps(fps);
+  return Math.round(seconds * fps);
+}
+function framesToSeconds(frames, fps) {
+  if (!Number.isInteger(frames) || frames < 0) throw new Error("frames must be a non-negative integer");
+  assertFps(fps);
+  return frames / fps;
+}
+function formatSeconds(seconds) {
+  return Number.isInteger(seconds) ? `${seconds}s` : `${seconds.toFixed(2)}s`;
+}
+function formatTimecode(frames, fps) {
+  assertFps(fps);
+  if (!Number.isInteger(frames) || frames < 0) throw new Error("frames must be a non-negative integer");
+  const totalSeconds = Math.floor(frames / fps);
+  const minutes = Math.floor(totalSeconds / 60);
+  const seconds = totalSeconds % 60;
+  const residualFrames = frames % fps;
+  return `${minutes}:${String(seconds).padStart(2, "0")}.${String(residualFrames).padStart(2, "0")}`;
+}
+function clampClipStart(input) {
+  assertSequenceDuration(input.sequenceDurationFrames);
+  assertClipDuration(input.durationFrames);
+  return Math.max(0, Math.min(input.sequenceDurationFrames - input.durationFrames, input.startFrame));
+}
+function clampClipDuration(input) {
+  assertSequenceDuration(input.sequenceDurationFrames);
+  if (input.startFrame < 0 || input.startFrame >= input.sequenceDurationFrames) {
+    throw new Error("startFrame must be inside the sequence");
+  }
+  return Math.max(MIN_SEQUENCE_CLIP_FRAMES, Math.min(input.durationFrames, input.sequenceDurationFrames - input.startFrame));
+}
+function assertClipFitsSequence(input) {
+  assertSequenceDuration(input.sequenceDurationFrames);
+  assertClipDuration(input.durationFrames);
+  if (!Number.isInteger(input.startFrame) || input.startFrame < 0) {
+    throw new Error(`${input.label} startFrame must be a non-negative integer`);
+  }
+  if (input.startFrame + input.durationFrames > input.sequenceDurationFrames) {
+    throw new Error(`${input.label} extends beyond the sequence duration`);
+  }
+}
+function chooseCaptionPlacement(input) {
+  const preferredDurationFrames = Math.min(input.fps * 3, input.sequenceDurationFrames);
+  const minimumDurationFrames = Math.min(input.fps, preferredDurationFrames);
+  const occupied = input.occupiedIntervals.map((interval) => ({
+    startFrame: Math.max(0, interval.startFrame),
+    endFrame: Math.min(input.sequenceDurationFrames, interval.endFrame)
+  })).filter((interval) => interval.endFrame > interval.startFrame).sort((a, b) => a.startFrame - b.startFrame);
+  const merged = [];
+  for (const interval of occupied) {
+    const last = merged[merged.length - 1];
+    if (last && interval.startFrame <= last.endFrame) last.endFrame = Math.max(last.endFrame, interval.endFrame);
+    else merged.push({ ...interval });
+  }
+  const gaps = [];
+  let cursor = 0;
+  for (const interval of merged) {
+    if (interval.startFrame > cursor) gaps.push({ startFrame: cursor, endFrame: interval.startFrame });
+    cursor = interval.endFrame;
+  }
+  if (cursor < input.sequenceDurationFrames) gaps.push({ startFrame: cursor, endFrame: input.sequenceDurationFrames });
+  const usable = gaps.filter((gap2) => gap2.endFrame - gap2.startFrame >= minimumDurationFrames);
+  const latestUsable = usable[usable.length - 1];
+  if (latestUsable === void 0) {
+    throw new Error(
+      `no free gap of at least ${minimumDurationFrames} frames on the caption track \u2014 pass explicit startFrame/durationFrames or clear space first`
+    );
+  }
+  const gap = usable.find((candidate) => candidate.endFrame > input.playheadFrame) ?? latestUsable;
+  const durationFrames = Math.min(preferredDurationFrames, gap.endFrame - gap.startFrame);
+  const startFrame = Math.max(gap.startFrame, Math.min(input.playheadFrame, gap.endFrame - durationFrames));
+  return { startFrame, durationFrames };
+}
+function snapshotFrame(timeline, frame) {
+  if (!Number.isInteger(frame) || frame < 0) throw new Error("frame must be a non-negative integer");
+  if (frame >= timeline.sequence.durationFrames) {
+    throw new Error(`frame ${frame} is beyond the sequence (${timeline.sequence.durationFrames} frames)`);
+  }
+  const trackById = new Map(timeline.tracks.map((track) => [track.id, track]));
+  const sortedTracks = [...timeline.tracks].sort((a, b) => a.sortOrder - b.sortOrder);
+  const trackOrder = new Map(sortedTracks.map((track, index) => [track.id, index]));
+  const active = timeline.clips.filter((clip) => !clip.disabled && clip.startFrame <= frame && frame < clip.startFrame + clip.durationFrames).map((clip) => {
+    const track = trackById.get(clip.trackId);
+    if (!track) throw new Error(`clip ${clip.id} references unknown track ${clip.trackId}`);
+    return { track, clip };
+  }).sort((a, b) => (trackOrder.get(a.track.id) ?? 0) - (trackOrder.get(b.track.id) ?? 0));
+  const captions = active.filter(({ track, clip }) => track.kind === "caption" && typeof clip.text === "string" && clip.text.length > 0).map(({ clip }) => ({ text: clip.text, language: clip.language, clipId: clip.id }));
+  return {
+    frame,
+    seconds: framesToSeconds(frame, timeline.sequence.fps),
+    active,
+    captions
+  };
+}
+function trackIntervals(timeline, trackId) {
+  return timeline.clips.filter((clip) => clip.trackId === trackId && !clip.disabled).map((clip) => ({ startFrame: clip.startFrame, endFrame: clip.startFrame + clip.durationFrames })).sort((a, b) => a.startFrame - b.startFrame);
+}
+function assertFps(fps) {
+  if (!Number.isInteger(fps) || fps <= 0) throw new Error("fps must be a positive integer");
+}
+function assertSequenceDuration(sequenceDurationFrames) {
+  if (!Number.isInteger(sequenceDurationFrames) || sequenceDurationFrames < MIN_SEQUENCE_CLIP_FRAMES) {
+    throw new Error("sequenceDurationFrames must be a positive integer");
+  }
+}
+function assertClipDuration(durationFrames) {
+  if (!Number.isInteger(durationFrames) || durationFrames < MIN_SEQUENCE_CLIP_FRAMES) {
+    throw new Error("durationFrames must be a positive integer");
+  }
+}
+
+export {
+  MIN_SEQUENCE_CLIP_FRAMES,
+  secondsToFrames,
+  framesToSeconds,
+  formatSeconds,
+  formatTimecode,
+  clampClipStart,
+  clampClipDuration,
+  assertClipFitsSequence,
+  chooseCaptionPlacement,
+  snapshotFrame,
+  trackIntervals
+};
+//# sourceMappingURL=chunk-ZYBWGSAZ.js.map

package/dist/chunk-ZYBWGSAZ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/sequences/model.ts"],"sourcesContent":["/**\n * Frame-accurate sequence timeline model — the product-agnostic spine of the\n * sequences surface. A sequence is a fixed-fps, fixed-duration timeline of\n * tracks; clips sit on tracks at integer frame positions with non-destructive\n * source in/out points. Products bind this model to their own storage through\n * `SequenceStore` (./store) and surface it to agents through the MCP toolset\n * (./mcp).\n *\n * All positions and durations are integer FRAMES at the sequence's fps.\n * Seconds appear only at the API edge (agent tools speak seconds; the\n * dispatcher converts exactly once). Nothing here touches a database, the DOM,\n * or React.\n */\n\nexport const MIN_SEQUENCE_CLIP_FRAMES = 1\n\n/** Track kinds. `reference` holds non-rendered guide media; `agent` holds the\n *  agent-decision lane rendered as markers, never as media. */\nexport type SequenceTrackKind = 'video' | 'audio' | 'caption' | 'reference' | 'agent'\n\nexport type SequenceStatus = 'draft' | 'active' | 'exporting' | 'archived'\n\nexport type SequenceExportFormat = 'mp4' | 'otio' | 'xml' | 'edl' | 'vtt' | 'srt' | 'contact_sheet'\n\nexport type SequenceExportStatus = 'queued' | 'processing' | 'completed' | 'failed' | 'cancelled'\n\nexport type SequenceMediaKind = 'video' | 'image' | 'audio'\n\nexport interface SequenceMeta {\n  id: string\n  title: string\n  fps: number\n  width: number\n  height: number\n  aspectRatio: string\n  durationFrames: number\n  status: SequenceStatus\n  metadata: Record<string, unknown>\n}\n\nexport interface SequenceTrack {\n  id: string\n  kind: SequenceTrackKind\n  name: string\n  sortOrder: number\n  locked: boolean\n  muted: boolean\n  metadata: Record<string, unknown>\n}\n\n/** Resolved playable media behind a clip. The store resolves product-specific\n *  references (generation rows, asset rows) into this shape; the core model\n *  never sees the product's tables. */\nexport interface SequenceClipMedia {\n  url: string\n  kind: SequenceMediaKind\n  /** Natural duration of the source media when known. */\n  durationSeconds?: number\n  /** Provider job state for media still rendering upstream. */\n  providerStatus?: 'queued' | 'processing' | 'completed' | 'failed'\n}\n\nexport interface SequenceClip {\n  id: string\n  trackId: string\n  label: string\n  startFrame: number\n  durationFrames: number\n  /** Source-relative in point (frames into the source media). */\n  sourceInFrame: number\n  /** Source-relative out point; null = natural end of the source. */\n  sourceOutFrame: number | null\n  disabled: boolean\n  /** Caption/text body for clips on caption tracks. */\n  text?: string\n  /** BCP-47 language tag for caption clips (e.g. 'en', 'es', 'ja'). */\n  language?: string\n  /** Opaque product reference to a generation row, when the clip came from one. */\n  generationId?: string\n  /** Opaque product reference to an asset row, when the clip came from one. */\n  assetId?: string\n  media?: SequenceClipMedia\n  metadata: Record<string, unknown>\n}\n\n/** One entry in the sequence's decision log — human edits, agent proposals,\n *  agent edits, exports, and notes all land here so the edit history is a\n *  single auditable lane. */\nexport interface SequenceDecision {\n  id: string\n  clipId: string | null\n  kind: 'human_edit' | 'agent_proposal' | 'agent_edit' | 'export' | 'note'\n  instruction: string\n  reasoningSummary: string | null\n  accepted: boolean | null\n  metadata: Record<string, unknown>\n  createdAt: Date\n}\n\nexport interface SequenceExportRecord {\n  id: string\n  format: SequenceExportFormat\n  status: SequenceExportStatus\n  resultUrl: string | null\n  metadata: Record<string, unknown>\n  createdAt: Date\n}\n\n/** The full timeline aggregate — what `get_timeline_state` returns and what\n *  every operation validates against. */\nexport interface SequenceTimeline {\n  sequence: SequenceMeta\n  tracks: SequenceTrack[]\n  clips: SequenceClip[]\n}\n\n/** What is on screen/audible at a single frame — the answer shape for\n *  \"what is happening at 0:34\". */\nexport interface SequenceFrameSnapshot {\n  frame: number\n  seconds: number\n  /** Active (enabled, in-range) clips at this frame, with their track. */\n  active: Array<{ track: SequenceTrack; clip: SequenceClip }>\n  /** Caption text visible at this frame, in track sort order. */\n  captions: Array<{ text: string; language?: string; clipId: string }>\n}\n\n// ---------------------------------------------------------------------------\n// Frame math\n// ---------------------------------------------------------------------------\n\nexport function secondsToFrames(seconds: number, fps: number): number {\n  if (!Number.isFinite(seconds) || seconds < 0) throw new Error('seconds must be a non-negative finite number')\n  assertFps(fps)\n  return Math.round(seconds * fps)\n}\n\nexport function framesToSeconds(frames: number, fps: number): number {\n  if (!Number.isInteger(frames) || frames < 0) throw new Error('frames must be a non-negative integer')\n  assertFps(fps)\n  return frames / fps\n}\n\nexport function formatSeconds(seconds: number): string {\n  return Number.isInteger(seconds) ? `${seconds}s` : `${seconds.toFixed(2)}s`\n}\n\n/** `m:ss.ff` timecode for UI and agent-readable frame references. */\nexport function formatTimecode(frames: number, fps: number): string {\n  assertFps(fps)\n  if (!Number.isInteger(frames) || frames < 0) throw new Error('frames must be a non-negative integer')\n  const totalSeconds = Math.floor(frames / fps)\n  const minutes = Math.floor(totalSeconds / 60)\n  const seconds = totalSeconds % 60\n  const residualFrames = frames % fps\n  return `${minutes}:${String(seconds).padStart(2, '0')}.${String(residualFrames).padStart(2, '0')}`\n}\n\nexport interface TimelineClipBounds {\n  startFrame: number\n  durationFrames: number\n}\n\nexport interface TimelineInterval {\n  startFrame: number\n  endFrame: number\n}\n\nexport function clampClipStart(input: {\n  startFrame: number\n  durationFrames: number\n  sequenceDurationFrames: number\n}): number {\n  assertSequenceDuration(input.sequenceDurationFrames)\n  assertClipDuration(input.durationFrames)\n  return Math.max(0, Math.min(input.sequenceDurationFrames - input.durationFrames, input.startFrame))\n}\n\nexport function clampClipDuration(input: {\n  startFrame: number\n  durationFrames: number\n  sequenceDurationFrames: number\n}): number {\n  assertSequenceDuration(input.sequenceDurationFrames)\n  if (input.startFrame < 0 || input.startFrame >= input.sequenceDurationFrames) {\n    throw new Error('startFrame must be inside the sequence')\n  }\n  return Math.max(MIN_SEQUENCE_CLIP_FRAMES, Math.min(input.durationFrames, input.sequenceDurationFrames - input.startFrame))\n}\n\nexport function assertClipFitsSequence(input: {\n  startFrame: number\n  durationFrames: number\n  sequenceDurationFrames: number\n  label: string\n}): void {\n  assertSequenceDuration(input.sequenceDurationFrames)\n  assertClipDuration(input.durationFrames)\n  if (!Number.isInteger(input.startFrame) || input.startFrame < 0) {\n    throw new Error(`${input.label} startFrame must be a non-negative integer`)\n  }\n  if (input.startFrame + input.durationFrames > input.sequenceDurationFrames) {\n    throw new Error(`${input.label} extends beyond the sequence duration`)\n  }\n}\n\n/** Place a caption near the playhead inside FREE space only — the caption\n *  track never double-books. Prefers fps*3 frames, floors at fps. The gap\n *  holding (or first after) the playhead wins; with everything ahead occupied\n *  the latest earlier gap is used instead. Throws when no gap can hold the\n *  minimum — the caller must supply explicit bounds or clear space. */\nexport function chooseCaptionPlacement(input: {\n  playheadFrame: number\n  fps: number\n  sequenceDurationFrames: number\n  occupiedIntervals: TimelineInterval[]\n}): TimelineClipBounds {\n  const preferredDurationFrames = Math.min(input.fps * 3, input.sequenceDurationFrames)\n  const minimumDurationFrames = Math.min(input.fps, preferredDurationFrames)\n  const occupied = input.occupiedIntervals\n    .map((interval) => ({\n      startFrame: Math.max(0, interval.startFrame),\n      endFrame: Math.min(input.sequenceDurationFrames, interval.endFrame),\n    }))\n    .filter((interval) => interval.endFrame > interval.startFrame)\n    .sort((a, b) => a.startFrame - b.startFrame)\n\n  // Merge overlaps so the gap walk sees each free run exactly once.\n  const merged: TimelineInterval[] = []\n  for (const interval of occupied) {\n    const last = merged[merged.length - 1]\n    if (last && interval.startFrame <= last.endFrame) last.endFrame = Math.max(last.endFrame, interval.endFrame)\n    else merged.push({ ...interval })\n  }\n\n  const gaps: TimelineInterval[] = []\n  let cursor = 0\n  for (const interval of merged) {\n    if (interval.startFrame > cursor) gaps.push({ startFrame: cursor, endFrame: interval.startFrame })\n    cursor = interval.endFrame\n  }\n  if (cursor < input.sequenceDurationFrames) gaps.push({ startFrame: cursor, endFrame: input.sequenceDurationFrames })\n\n  const usable = gaps.filter((gap) => gap.endFrame - gap.startFrame >= minimumDurationFrames)\n  const latestUsable = usable[usable.length - 1]\n  if (latestUsable === undefined) {\n    throw new Error(\n      `no free gap of at least ${minimumDurationFrames} frames on the caption track — pass explicit startFrame/durationFrames or clear space first`,\n    )\n  }\n  const gap = usable.find((candidate) => candidate.endFrame > input.playheadFrame) ?? latestUsable\n  const durationFrames = Math.min(preferredDurationFrames, gap.endFrame - gap.startFrame)\n  const startFrame = Math.max(gap.startFrame, Math.min(input.playheadFrame, gap.endFrame - durationFrames))\n  return { startFrame, durationFrames }\n}\n\n/** Resolve everything active at one frame — the core of `get_frame_at_time`. */\nexport function snapshotFrame(timeline: SequenceTimeline, frame: number): SequenceFrameSnapshot {\n  if (!Number.isInteger(frame) || frame < 0) throw new Error('frame must be a non-negative integer')\n  if (frame >= timeline.sequence.durationFrames) {\n    throw new Error(`frame ${frame} is beyond the sequence (${timeline.sequence.durationFrames} frames)`)\n  }\n  const trackById = new Map(timeline.tracks.map((track) => [track.id, track]))\n  const sortedTracks = [...timeline.tracks].sort((a, b) => a.sortOrder - b.sortOrder)\n  const trackOrder = new Map(sortedTracks.map((track, index) => [track.id, index]))\n\n  const active = timeline.clips\n    .filter((clip) => !clip.disabled && clip.startFrame <= frame && frame < clip.startFrame + clip.durationFrames)\n    .map((clip) => {\n      const track = trackById.get(clip.trackId)\n      if (!track) throw new Error(`clip ${clip.id} references unknown track ${clip.trackId}`)\n      return { track, clip }\n    })\n    .sort((a, b) => (trackOrder.get(a.track.id) ?? 0) - (trackOrder.get(b.track.id) ?? 0))\n\n  const captions = active\n    .filter(({ track, clip }) => track.kind === 'caption' && typeof clip.text === 'string' && clip.text.length > 0)\n    .map(({ clip }) => ({ text: clip.text as string, language: clip.language, clipId: clip.id }))\n\n  return {\n    frame,\n    seconds: framesToSeconds(frame, timeline.sequence.fps),\n    active,\n    captions,\n  }\n}\n\n/** Occupied intervals on one track, for placement collision checks. */\nexport function trackIntervals(timeline: SequenceTimeline, trackId: string): TimelineInterval[] {\n  return timeline.clips\n    .filter((clip) => clip.trackId === trackId && !clip.disabled)\n    .map((clip) => ({ startFrame: clip.startFrame, endFrame: clip.startFrame + clip.durationFrames }))\n    .sort((a, b) => a.startFrame - b.startFrame)\n}\n\nfunction assertFps(fps: number): void {\n  if (!Number.isInteger(fps) || fps <= 0) throw new Error('fps must be a positive integer')\n}\n\nfunction assertSequenceDuration(sequenceDurationFrames: number): void {\n  if (!Number.isInteger(sequenceDurationFrames) || sequenceDurationFrames < MIN_SEQUENCE_CLIP_FRAMES) {\n    throw new Error('sequenceDurationFrames must be a positive integer')\n  }\n}\n\nfunction assertClipDuration(durationFrames: number): void {\n  if (!Number.isInteger(durationFrames) || durationFrames < MIN_SEQUENCE_CLIP_FRAMES) {\n    throw new Error('durationFrames must be a positive integer')\n  }\n}\n"],"mappings":"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","names":["gap"]}

package/dist/index.d.ts

@@ -1,8 +1,9 @@
-export { APP_TOOL_NAMES, AppToolMcpServer, AppToolName, AppToolRuntimeExecutor, AuthenticateOptions, BuildHttpMcpServerOptions, BuildMcpServerOptions, CapabilityTokenOptions, DEFAULT_APP_TOOL_PATHS, DEFAULT_HEADER_NAMES, DispatchOptions, HandleToolRequestOptions, OpenAIFunctionTool, RuntimeExecutorOptions, ToolAuthResult, ToolHeaderNames, ToolInputError, authenticateToolRequest, buildAppToolMcpServer, buildAppToolOpenAITools, buildHttpMcpServer, createAppToolRuntimeExecutor, createCapabilityToken, dispatchAppTool, handleAppToolRequest, isAppToolName, outcomeStatus, readToolArgs, verifyCapabilityToken } from './tools/index.js';
+export { AppToolRuntimeExecutor, CapabilityTokenOptions, DispatchOptions, ExpiringCapabilityTokenOptions, HandleToolRequestOptions, RuntimeExecutorOptions, ToolInputError, createAppToolRuntimeExecutor, createCapabilityToken, createExpiringCapabilityToken, dispatchAppTool, handleAppToolRequest, outcomeStatus, verifyCapabilityToken, verifyExpiringCapabilityToken } from './tools/index.js';
+export { A as APP_TOOL_NAMES, a as AppToolMcpServer, b as AppToolName, 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, f as ToolHeaderNames, g as authenticateToolRequest, h as buildAppToolMcpServer, i as buildAppToolOpenAITools, j as buildHttpMcpServer, k as isAppToolName, r as readToolArgs } from './mcp-CIupfjxV.js';
 export { A as AddCitationArgs, a as AddCitationResult, b as AppToolContext, c as AppToolHandlers, d as AppToolOutcome, e as AppToolProducedEvent, f as AppToolTaxonomy, R as RenderUiArgs, g as RenderUiResult, S as ScheduleFollowupArgs, h as ScheduleFollowupResult, i as SubmitProposalArgs, j as SubmitProposalResult } from './types-By4B3K37.js';
 export { BuildDelegationOptions, DELEGATION_MCP_SERVER_KEY, DELEGATION_TOOLS, DelegationMcpServer, buildDelegationMcpServer, delegationMcpForConfig } from './delegation/index.js';
 export { BrokerToken, BrokerTokenMinter, BrokerTokenProvider, BrokerTokenProviderOptions, ConsentUrlInput, buildConsentUrl, createBrokerTokenProvider } from './tangle/index.js';
-export { AgentRuntime, AgentRuntimeModelConfig, AgentTurnOptions, AppToolLoopOptions, CreateAgentRuntimeOptions, LoopAssistantToolCall, LoopEvent, LoopMessage, LoopToolCall, OpenAICompatStreamTurnOptions, OpenAIStreamChunk, StreamAppToolLoopOptions, StreamLoopYield, ToolLoopResult, ToolLoopStopReason, createAgentRuntime, createOpenAICompatStreamTurn, runAppToolLoop, streamAppToolLoop, toLoopEvents } from './runtime/index.js';
+export { AgentRuntime, AgentRuntimeModelConfig, AgentTurnOptions, AnySurfaceKind, AppToolLoopOptions, CreateAgentRuntimeOptions, LoopAssistantToolCall, LoopEvent, LoopMessage, LoopToolCall, OpenAICompatStreamTurnOptions, OpenAIStreamChunk, StreamAppToolLoopOptions, StreamLoopYield, SurfaceKindDefinition, SurfaceMcpServer, SurfaceMergeBase, SurfaceOverlay, SurfacePermissionValue, SurfaceRegistry, ToolLoopResult, ToolLoopStopReason, createAgentRuntime, createOpenAICompatStreamTurn, createSurfaceRegistry, defineSurfaceKind, mergeSurfaceOverlay, runAppToolLoop, streamAppToolLoop, toLoopEvents } from './runtime/index.js';
 export { createTokenRecallChecker, producedFromToolEvents } from './eval/index.js';
 export { KnowledgeRequirementSpec, KnowledgeSignal, KnowledgeStateAccessor, SatisfiedByRule, buildKnowledgeRequirements, deriveSignals } from './knowledge/index.js';
 export { CreateKnowledgeLoopDeps, KnowledgeCandidate, KnowledgeDecider, KnowledgeDeciderInput, KnowledgeDecision, KnowledgeGateVerdict, KnowledgeLoop, KnowledgeLoopDriver, createKnowledgeLoop, createReviewerDecider, reviewCandidate } from './knowledge-loop/index.js';
@@ -19,6 +20,9 @@ export { CookieOptions, JsonObject, KvLike, RateLimitResult, RequestContext, Sec
 export { BuildRedactedDocumentOptions, DEFAULT_REDACTION_PATTERNS, RedactForIngestionOptions, RedactedDocSegment, RedactedDocument, RedactionPattern, RedactionSpan, RevealResult, RevealSpanOptions, buildRedactedDocument, detectSpans, maskSpans, redactForIngestion, revealSpan } from './redact/index.js';
 export { ApprovalEvent, ApprovalEventSchema, AssetContentMap, AssetFormat, AssetSpec, AssetStatus, AssetVariant, BrandTokens, BrandTokensSchema, ConversionMetrics, ConversionMetricsSchema, CopyContent, CopyContentSchema, CopyPlatform, EmailBodySection, EmailContent, EmailContentSchema, EmailCtaSection, EmailDividerSection, EmailFeatureSection, EmailHeroSection, EmailSection, EmailTestimonialSection, ImageBackground, ImageContent, ImageContentSchema, ImageImageLayer, ImageLayer, ImageLayerType, ImageLogoLayer, ImageShapeLayer, ImageSlide, ImageTextLayer, VideoCaption, VideoContent, VideoContentSchema, VideoCountdownScene, VideoImageRevealScene, VideoScene, VideoSlideScene, VideoTextAnimationScene, parseAssetSpec, safeParseAssetSpec } from './assets/index.js';
 export { DistributionSummary, FlowSpan, FlowTrace, LoopTraceEventLike, MissionFlowStep, MissionTraceContext, StepSpanContext, TimedEvent, buildFlowTrace, childSpanContext, composeMissionFlowTrace, createMissionTraceContext, delegationActivityToFlowSpans, loopTraceEventsToFlowSpans, renderHistogram, renderWaterfall, stepActivityFlowTrace, summarize, timedEventsFromLines, traceEnv } from './trace/index.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, j as SequenceMediaKind, k as SequenceMeta, l as SequenceStatus, m as SequenceStore, n as SequenceStoreScope, o as SequenceTimeline, p as SequenceTrack, q as SequenceTrackKind, T as TimelineClipBounds, r as TimelineInterval, 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';
+export { BuildCaptionChunksOptions, BuildSequencesMcpServerEntryOptions, CaptionChunk, CaptionCoverageEntry, CaptionExportOptions, ContactSheetEntry, ContactSheetManifest, CreateSequencesMcpHandlerOptions, DEFAULT_SEQUENCES_MCP_DESCRIPTION, LanguageFanoutOptions, MAX_CAPTION_BATCH, OtioClip, OtioExternalReference, OtioGap, OtioMissingReference, OtioRationalTime, OtioStack, OtioTimeRange, OtioTimeline, OtioTrack, SEQUENCES_MCP_PROTOCOL_VERSIONS, SEQUENCE_EXPORT_FORMATS, SEQUENCE_MCP_TOOLS, SEQUENCE_MEDIA_KINDS, SEQUENCE_TRACK_KINDS, SequenceMcpToolDefinition, SequenceMcpToolEnv, SequencesMcpServerInfo, TranscriptSegment, buildCaptionChunks, buildContactSheetManifest, buildEdl, buildOtio, buildSequencesMcpServerEntry, buildSrt, buildVtt, captionCoverage, createSequencesMcpHandler, findSequenceMcpTool, normalizeLanguageTag, planLanguageFanout } from './sequences/index.js';
 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 { CompletionRequirement, CompletionVerdict, CorrectnessChecker, ProducedState, RuntimeEventLike, SatisfiedBy, TaskGold, createLlmCorrectnessChecker, extractProducedState, verifyCompletion, weightedComposite } from '@tangle-network/agent-eval';
 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';

package/dist/index.js

@@ -1,3 +1,60 @@
+import {
+  DEFAULT_SEQUENCES_MCP_DESCRIPTION,
+  MAX_CAPTION_BATCH,
+  SEQUENCES_MCP_PROTOCOL_VERSIONS,
+  SEQUENCE_EXPORT_FORMATS,
+  SEQUENCE_MCP_TOOLS,
+  SEQUENCE_MEDIA_KINDS,
+  SEQUENCE_OPERATION_TYPES,
+  SEQUENCE_TRACK_KINDS,
+  applySequenceOperation,
+  applySequenceOperations,
+  assertSequenceMediaUrl,
+  buildCaptionChunks,
+  buildContactSheetManifest,
+  buildEdl,
+  buildOtio,
+  buildSequencesMcpServerEntry,
+  buildSrt,
+  buildVtt,
+  captionCoverage,
+  captionTrackNameForLanguage,
+  createSequencesMcpHandler,
+  findSequenceMcpTool,
+  lastClipEndFrame,
+  normalizeLanguageTag,
+  parseSequenceOperations,
+  planLanguageFanout,
+  resolveCaptionPlacement,
+  resolveCaptionTarget,
+  resolvePlaceClipTrack,
+  validateAddCaption,
+  validateCreateTrack,
+  validateDeleteClip,
+  validateExtendSequence,
+  validateMoveClip,
+  validatePlaceClip,
+  validateQueueExport,
+  validateSequenceOperation,
+  validateSequenceOperations,
+  validateSetClipDisabled,
+  validateSetClipText,
+  validateSplitClip,
+  validateTrimClip
+} from "./chunk-3WAJWYKD.js";
+import {
+  MIN_SEQUENCE_CLIP_FRAMES,
+  assertClipFitsSequence,
+  chooseCaptionPlacement,
+  clampClipDuration,
+  clampClipStart,
+  formatSeconds,
+  formatTimecode,
+  framesToSeconds,
+  secondsToFrames,
+  snapshotFrame,
+  trackIntervals
+} from "./chunk-ZYBWGSAZ.js";
 import {
   DEFAULT_MISSION_STEP_KINDS,
   MISSION_CONTROL_CHANNEL_ID,
@@ -91,12 +148,12 @@ import {
   createPresetToolHandlers,
   createPresetWorkspaceKeyManager,
   createPresetWorkspaceKeyStore
-} from "./chunk-EYXTDVDY.js";
+} from "./chunk-SAOAAA3S.js";
 import {
   createPlatformBalanceManager,
   createTcloudKeyProvisioner,
   createWorkspaceKeyManager
-} from "./chunk-YS6A6G57.js";
+} from "./chunk-G3HCU7TA.js";
 import {
   createFieldCrypto,
   decodeHexKey,
@@ -136,17 +193,21 @@ import {
   invokeIntegrationHub,
   resolveIntegrationAction
 } from "./chunk-L2TG5DBW.js";
+import {
+  createCapabilityToken,
+  createExpiringCapabilityToken,
+  handleAppToolRequest,
+  verifyCapabilityToken,
+  verifyExpiringCapabilityToken
+} from "./chunk-CF5DZELC.js";
 import {
   DEFAULT_APP_TOOL_PATHS,
   DEFAULT_HEADER_NAMES,
   authenticateToolRequest,
   buildAppToolMcpServer,
   buildHttpMcpServer,
-  createCapabilityToken,
-  handleAppToolRequest,
-  readToolArgs,
-  verifyCapabilityToken
-} from "./chunk-OLCVUGGI.js";
+  readToolArgs
+} from "./chunk-IJZJWKUK.js";
 import {
   DELEGATION_MCP_SERVER_KEY,
   DELEGATION_TOOLS,
@@ -162,12 +223,15 @@ import {
   buildCatalog,
   createAgentRuntime,
   createOpenAICompatStreamTurn,
+  createSurfaceRegistry,
+  defineSurfaceKind,
   fetchModelCatalog,
+  mergeSurfaceOverlay,
   normalizeModelId,
   runAppToolLoop,
   streamAppToolLoop,
   toLoopEvents
-} from "./chunk-4YTWB5MG.js";
+} from "./chunk-ETX4O4BB.js";
 import {
   DEFAULT_TANGLE_BILLING_ENFORCEMENT_ENV_VAR,
   DEFAULT_TANGLE_ROUTER_BASE_URL,
@@ -213,6 +277,7 @@ export {
   DEFAULT_HEADER_NAMES,
   DEFAULT_MISSION_STEP_KINDS,
   DEFAULT_REDACTION_PATTERNS,
+  DEFAULT_SEQUENCES_MCP_DESCRIPTION,
   DEFAULT_TANGLE_BILLING_ENFORCEMENT_ENV_VAR,
   DEFAULT_TANGLE_ROUTER_BASE_URL,
   DELEGATION_MCP_SERVER_KEY,
@@ -221,11 +286,19 @@ export {
   HubExecClient,
   ImageContentSchema,
   KNOWN_HARNESSES,
+  MAX_CAPTION_BATCH,
+  MIN_SEQUENCE_CLIP_FRAMES,
   MISSION_CONTROL_CHANNEL_ID,
   MissionConcurrencyError,
   PRESET_MIGRATION_SQL,
   PRESET_TABLES,
   RetryableStepError,
+  SEQUENCES_MCP_PROTOCOL_VERSIONS,
+  SEQUENCE_EXPORT_FORMATS,
+  SEQUENCE_MCP_TOOLS,
+  SEQUENCE_MEDIA_KINDS,
+  SEQUENCE_OPERATION_TYPES,
+  SEQUENCE_TRACK_KINDS,
   TURN_EVENTS_MIGRATION_SQL,
   TangleExecutionKeyError,
   ToolInputError,
@@ -234,24 +307,40 @@ export {
   addSecurityHeaders,
   agentAppConfigJsonSchema,
   applyMissionEvent,
+  applySequenceOperation,
+  applySequenceOperations,
   asMissionStreamEvent,
   asRecord,
   asString,
+  assertClipFitsSequence,
+  assertSequenceMediaUrl,
   authenticateToolRequest,
   budgetGateProposalId,
   buildAgentMissionPlan,
   buildAppToolMcpServer,
   buildAppToolOpenAITools,
+  buildCaptionChunks,
   buildCatalog,
   buildConsentUrl,
+  buildContactSheetManifest,
   buildDelegationMcpServer,
+  buildEdl,
   buildFlowTrace,
   buildHttpMcpServer,
   buildKnowledgeRequirements,
+  buildOtio,
   buildRedactedDocument,
+  buildSequencesMcpServerEntry,
+  buildSrt,
   buildUserTextParts,
+  buildVtt,
+  captionCoverage,
+  captionTrackNameForLanguage,
   checkRateLimit,
   childSpanContext,
+  chooseCaptionPlacement,
+  clampClipDuration,
+  clampClipStart,
   clearCookieHeader,
   coalesceDeltas,
   coerceHarness,
@@ -262,6 +351,7 @@ export {
   createCapabilityToken,
   createD1KnowledgeStateAccessor,
   createD1TurnEventStore,
+  createExpiringCapabilityToken,
   createFieldCrypto,
   createInMemoryMissionStore,
   createKnowledgeLoop,
@@ -278,6 +368,8 @@ export {
   createPresetWorkspaceKeyManager,
   createPresetWorkspaceKeyStore,
   createReviewerDecider,
+  createSequencesMcpHandler,
+  createSurfaceRegistry,
   createTangleRouterModelConfig,
   createTcloudKeyProvisioner,
   createTokenRecallChecker,
@@ -287,6 +379,7 @@ export {
   decryptBytes,
   decryptWithKey,
   defineAgentApp,
+  defineSurfaceKind,
   delegationActivityToFlowSpans,
   delegationMcpForConfig,
   deriveKey,
@@ -301,6 +394,10 @@ export {
   extractRequestContext,
   fetchModelCatalog,
   finalizeAssistantParts,
+  findSequenceMcpTool,
+  formatSeconds,
+  formatTimecode,
+  framesToSeconds,
   getPartKey,
   handleAppToolRequest,
   invokeIntegrationHub,
@@ -310,13 +407,16 @@ export {
   isMissionTerminal,
   isTangleBillingEnforcementDisabled,
   isTangleExecutionKeyError,
+  lastClipEndFrame,
   loopTraceEventsToFlowSpans,
   maskSpans,
   mergeMissionState,
   mergePersistedPart,
+  mergeSurfaceOverlay,
   messageHasTurnId,
   noopEventSink,
   normalizeClientTurnId,
+  normalizeLanguageTag,
   normalizeModelId,
   normalizePersistedPart,
   normalizeTime,
@@ -325,7 +425,9 @@ export {
   parseAssetSpec,
   parseJsonObjectBody,
   parseMissionBlocks,
+  parseSequenceOperations,
   parseSessionStreamEnvelope,
+  planLanguageFanout,
   producedFromToolEvents,
   pumpBufferedTurn,
   readCookieValue,
@@ -336,8 +438,11 @@ export {
   renderWaterfall,
   replayTurnEvents,
   requireString,
+  resolveCaptionPlacement,
+  resolveCaptionTarget,
   resolveChatTurn,
   resolveIntegrationAction,
+  resolvePlaceClipTrack,
   resolveSessionHarness,
   resolveTangleExecutionEnvironment,
   resolveTangleModelConfig,
@@ -349,7 +454,9 @@ export {
   reviewCandidate,
   runAppToolLoop,
   safeParseAssetSpec,
+  secondsToFrames,
   serializeCookie,
+  snapshotFrame,
   stepActivityFlowTrace,
   stepAgentActivity,
   stepGateProposalId,
@@ -359,8 +466,23 @@ export {
   timedEventsFromLines,
   toLoopEvents,
   traceEnv,
+  trackIntervals,
+  validateAddCaption,
+  validateCreateTrack,
+  validateDeleteClip,
+  validateExtendSequence,
+  validateMoveClip,
+  validatePlaceClip,
+  validateQueueExport,
+  validateSequenceOperation,
+  validateSequenceOperations,
+  validateSetClipDisabled,
+  validateSetClipText,
+  validateSplitClip,
+  validateTrimClip,
   verifyCapabilityToken,
   verifyCompletion,
+  verifyExpiringCapabilityToken,
   volumeGateProposalId,
   weightedComposite
 };

package/dist/mcp-CIupfjxV.d.ts

@@ -0,0 +1,112 @@
+import { f as AppToolTaxonomy, b as AppToolContext } from './types-By4B3K37.js';
+
+/** The four canonical app-tool names. Stable identifiers the model calls in
+ *  both the sandbox (MCP server name) and runtime (function-tool name) paths. */
+declare const APP_TOOL_NAMES: readonly ["submit_proposal", "schedule_followup", "render_ui", "add_citation"];
+type AppToolName = (typeof APP_TOOL_NAMES)[number];
+declare function isAppToolName(name: string): name is AppToolName;
+/** A minimal OpenAI Chat Completions function-tool shape — structurally
+ *  compatible with `@tangle-network/agent-runtime`'s `OpenAIChatTool` without
+ *  importing it (keeps this package runtime-free). */
+interface OpenAIFunctionTool {
+    type: 'function';
+    function: {
+        name: string;
+        description: string;
+        parameters: Record<string, unknown>;
+    };
+}
+/**
+ * Build the four app tools in OpenAI function-tool shape. `submit_proposal`'s
+ * `type` enum is the product's {@link AppToolTaxonomy.proposalTypes}; the other
+ * three are fixed. Pass the result to the agent-runtime backend's `tools`.
+ */
+declare function buildAppToolOpenAITools(taxonomy: AppToolTaxonomy): OpenAIFunctionTool[];
+
+/**
+ * Header names carrying the server-set per-turn context + the capability token.
+ * Defaults are product-neutral (`X-Agent-App-*`); a product that already ships
+ * a header convention (e.g. `X-Acme-User-Id`) passes its own.
+ */
+interface ToolHeaderNames {
+    userId: string;
+    workspaceId: string;
+    threadId: string;
+}
+declare const DEFAULT_HEADER_NAMES: ToolHeaderNames;
+interface AuthenticateOptions {
+    /** Verify the bearer capability token belongs to `userId`. The product's
+     *  HMAC/JWT impl — the seam that keeps token crypto out of this package. */
+    verifyToken: (userId: string, bearer: string) => Promise<boolean>;
+    headerNames?: ToolHeaderNames;
+}
+type ToolAuthResult = {
+    ok: true;
+    ctx: AppToolContext;
+} | {
+    ok: false;
+    response: Response;
+};
+/**
+ * Recover + verify the trusted context for a tool request. The user comes from
+ * a server-set header and the bearer token MUST verify against THAT user; the
+ * workspace comes from a header too — never from tool args — so the model can
+ * neither forge identity nor target another workspace. Fail-closed: any missing
+ * credential or a token minted for another user yields a 401/400 Response.
+ */
+declare function authenticateToolRequest(request: Request, opts: AuthenticateOptions): Promise<ToolAuthResult>;
+/** Read a tool's argument object from the request body, tolerant of MCP host
+ *  aliases (`args` / `arguments`) or a bare body. Returns null on non-JSON. */
+declare function readToolArgs<T>(request: Request): Promise<T | null>;
+
+/** 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}). */
+declare const DEFAULT_APP_TOOL_PATHS: Record<AppToolName, string>;
+/** The portable MCP server entry the sandbox SDK accepts (transport + url +
+ *  headers). Matches `AgentProfileMcpServer` structurally without importing the
+ *  sandbox SDK — products spread it into their profile's `mcp` map. */
+interface AppToolMcpServer {
+    transport: 'http';
+    url: string;
+    headers: Record<string, string>;
+    enabled: true;
+    metadata: {
+        description: string;
+    };
+}
+interface BuildHttpMcpServerOptions {
+    /** Route path on the app the sandbox POSTs to (e.g. `/api/tools/propose`). */
+    path: string;
+    /** App base URL the sandbox reaches back to (no trailing slash required). */
+    baseUrl: string;
+    /** Per-user capability token, baked into the Authorization header. */
+    token: string;
+    ctx: AppToolContext;
+    /** Tool description the model sees. */
+    description: string;
+    headerNames?: ToolHeaderNames;
+}
+/**
+ * Build ONE HTTP MCP server entry — the generic agent→app bridge. The
+ * capability token + the user/workspace/thread ids ride in server-set headers
+ * (never tool args), so the model can't forge identity or target another
+ * workspace. Workspace/thread headers are omitted when their `ctx` value is
+ * empty/null (e.g. an integration-invoke bridge that's user-scoped only). Used
+ * directly for non-app-tool bridges (integration_invoke) and via
+ * {@link buildAppToolMcpServer} for the four app tools.
+ */
+declare function buildHttpMcpServer(opts: BuildHttpMcpServerOptions): AppToolMcpServer;
+interface BuildMcpServerOptions {
+    tool: AppToolName;
+    baseUrl: string;
+    token: string;
+    ctx: AppToolContext;
+    description: string;
+    headerNames?: ToolHeaderNames;
+    paths?: Partial<Record<AppToolName, string>>;
+}
+/** Build one of the four app-tool MCP servers — a thin wrapper over
+ *  {@link buildHttpMcpServer} that maps the tool name to its route path. */
+declare function buildAppToolMcpServer(opts: BuildMcpServerOptions): AppToolMcpServer;
+
+export { APP_TOOL_NAMES as A, type BuildHttpMcpServerOptions as B, DEFAULT_APP_TOOL_PATHS as D, type OpenAIFunctionTool as O, type ToolAuthResult as T, type AppToolMcpServer as a, type AppToolName as b, type AuthenticateOptions as c, type BuildMcpServerOptions as d, DEFAULT_HEADER_NAMES as e, type ToolHeaderNames as f, authenticateToolRequest as g, buildAppToolMcpServer as h, buildAppToolOpenAITools as i, buildHttpMcpServer as j, isAppToolName as k, readToolArgs as r };

package/dist/preset-cloudflare/index.js

@@ -7,8 +7,8 @@ import {
   createPresetToolHandlers,
   createPresetWorkspaceKeyManager,
   createPresetWorkspaceKeyStore
-} from "../chunk-EYXTDVDY.js";
-import "../chunk-YS6A6G57.js";
+} from "../chunk-SAOAAA3S.js";
+import "../chunk-G3HCU7TA.js";
 import "../chunk-TA5Q4I2K.js";
 export {
   PRESET_MIGRATION_SQL,