@tangle-network/agent-app 0.11.1 → 0.13.0

package/dist/model-BHLN208Z.d.ts

@@ -0,0 +1,183 @@
+/**
+ * Design-canvas scene model — the product-agnostic document behind the visual
+ * asset editor. A document is an ordered list of pages; a page is an ordered
+ * list of elements (index order IS z-order, bottom→top); every element is a
+ * typed node with a closed attribute vocabulary. The whole document
+ * serializes as one JSON value and persists atomically with a revision
+ * counter (see ./store) — every canvas action is a durable operation against
+ * this schema, which is what makes the canvas automatable: agents and
+ * external data sources mutate the same document the editor renders.
+ *
+ * Units are CSS pixels throughout; `settings.dpi` carries the print
+ * conversion factor for bleed/trim-aware exports. Angles are degrees.
+ * Nothing here touches Konva, React, or a database.
+ */
+declare const SCENE_SCHEMA_VERSION = 1;
+interface SceneDocument {
+    schemaVersion: typeof SCENE_SCHEMA_VERSION;
+    title: string;
+    pages: ScenePage[];
+    settings: SceneSettings;
+    metadata: Record<string, unknown>;
+}
+interface SceneSettings {
+    /** Print conversion factor for mm↔px math at export; 96 = CSS default. */
+    dpi: number;
+}
+/** Per-side bleed extents in px, drawn OUTSIDE the page bounds. Trim = the
+ *  page rect itself; exports may include or exclude the bleed area. */
+interface PageBleed {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+}
+/** Saved ruler guides, in page coordinates. */
+interface PageGuides {
+    vertical: number[];
+    horizontal: number[];
+}
+interface ScenePage {
+    id: string;
+    name: string;
+    width: number;
+    height: number;
+    /** Page background fill (color string); elements paint over it. */
+    background: string;
+    bleed: PageBleed | null;
+    guides: PageGuides;
+    elements: SceneElement[];
+}
+/** Attributes every element carries. `x`/`y` are the element's top-left in
+ *  page coordinates (for `group`, children are relative to the group origin).
+ *  `slot` names a template binding point — `apply_data` targets it. */
+interface SceneElementBase {
+    id: string;
+    name: string;
+    x: number;
+    y: number;
+    /** Degrees, clockwise, about the element's top-left origin (Konva default). */
+    rotation: number;
+    /** 0..1 */
+    opacity: number;
+    locked: boolean;
+    visible: boolean;
+    slot?: string;
+}
+interface RectElement extends SceneElementBase {
+    kind: 'rect';
+    width: number;
+    height: number;
+    fill: string;
+    stroke?: string;
+    strokeWidth?: number;
+    cornerRadius?: number;
+}
+interface EllipseElement extends SceneElementBase {
+    kind: 'ellipse';
+    width: number;
+    height: number;
+    fill: string;
+    stroke?: string;
+    strokeWidth?: number;
+}
+interface LineElement extends SceneElementBase {
+    kind: 'line';
+    /** Flat [x0, y0, x1, y1, ...] relative to (x, y); ≥ 2 points. */
+    points: number[];
+    stroke: string;
+    strokeWidth: number;
+    dash?: number[];
+}
+interface TextElement extends SceneElementBase {
+    kind: 'text';
+    text: string;
+    /** Wrap width; height derives from content. */
+    width: number;
+    fontFamily: string;
+    fontSize: number;
+    fontStyle: 'normal' | 'bold' | 'italic' | 'bold italic';
+    fill: string;
+    align: 'left' | 'center' | 'right';
+    lineHeight: number;
+    letterSpacing: number;
+}
+interface ImageElement extends SceneElementBase {
+    kind: 'image';
+    width: number;
+    height: number;
+    /** http(s) or rooted /api/ path — same boundary rule as sequences media. */
+    src: string;
+    /** How the source maps into the frame; 'fill' stretches, 'cover' crops. */
+    fit: 'fill' | 'cover' | 'contain';
+}
+/** Video placed on a canvas renders and exports as its poster frame — motion
+ *  belongs to the sequences surface; this keeps video assets placeable in
+ *  static layouts (e.g. a thumbnail mock) without a playback engine. */
+interface VideoElement extends SceneElementBase {
+    kind: 'video';
+    width: number;
+    height: number;
+    src: string;
+    posterSrc?: string;
+}
+interface GroupElement extends SceneElementBase {
+    kind: 'group';
+    children: SceneElement[];
+}
+type SceneElement = RectElement | EllipseElement | LineElement | TextElement | ImageElement | VideoElement | GroupElement;
+type SceneElementKind = SceneElement['kind'];
+declare const SCENE_ELEMENT_KINDS: readonly SceneElementKind[];
+interface Bounds {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/** Unrotated local extent of an element (line/group derive from content). */
+declare function elementExtent(element: SceneElement): {
+    width: number;
+    height: number;
+};
+declare function estimateTextHeight(element: Pick<TextElement, 'text' | 'fontSize' | 'lineHeight'>): number;
+/** Axis-aligned bounding box in the parent's coordinate space, accounting for
+ *  rotation about the element's top-left origin. */
+declare function elementAabb(element: SceneElement): Bounds;
+declare function boundsIntersect(a: Bounds, b: Bounds): boolean;
+declare function requirePage(document: SceneDocument, pageId: string): ScenePage;
+/** Depth-first search across a page including group children. Returns the
+ *  element and the array that owns it (page.elements or a group's children),
+ *  so callers can splice in place. */
+declare function findElement(page: ScenePage, elementId: string): {
+    element: SceneElement;
+    owner: SceneElement[];
+    index: number;
+} | null;
+declare function requireElement(page: ScenePage, elementId: string): {
+    element: SceneElement;
+    owner: SceneElement[];
+    index: number;
+};
+/** All slot names declared across the document — the template's fillable
+ *  surface. Duplicate slot names are a validation error (see ./validate). */
+declare function collectSlots(document: SceneDocument): Map<string, {
+    pageId: string;
+    elementId: string;
+    kind: SceneElementKind;
+}>;
+interface NewPageOptions {
+    name?: string;
+    width?: number;
+    height?: number;
+    background?: string;
+}
+declare function createEmptyDocument(title: string, page?: NewPageOptions): SceneDocument;
+declare function createPage(options: NewPageOptions, id: string): ScenePage;
+declare function assertPositiveFinite(value: number, label: string): void;
+declare function assertFinite(value: number, label: string): void;
+declare function assertColor(value: string, label: string): void;
+/** Media boundary rule shared with sequences: remote http(s) or a rooted
+ *  /api/ path — never sandbox-local files or data: blobs. */
+declare function assertSceneMediaSrc(value: string, label: string): void;
+
+export { type Bounds as B, type EllipseElement as E, type GroupElement as G, type ImageElement as I, type LineElement as L, type NewPageOptions as N, type PageBleed as P, type RectElement as R, SCENE_ELEMENT_KINDS as S, type TextElement as T, type VideoElement as V, type PageGuides as a, SCENE_SCHEMA_VERSION as b, type SceneDocument as c, type SceneElement as d, type SceneElementBase as e, type SceneElementKind as f, type ScenePage as g, type SceneSettings as h, assertColor as i, assertFinite as j, assertPositiveFinite as k, assertSceneMediaSrc as l, boundsIntersect as m, collectSlots as n, createEmptyDocument as o, createPage as p, elementAabb as q, elementExtent as r, estimateTextHeight as s, findElement as t, requireElement as u, requirePage as v };

package/dist/runtime/index.d.ts

@@ -1,6 +1,7 @@
 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';
 
 /**
  * OpenAI-compatible stream → `LoopEvent` adapter, for NON-sandbox copilots.
@@ -170,6 +171,112 @@ interface AgentRuntime {
  */
 declare function createAgentRuntime(opts: CreateAgentRuntimeOptions): AgentRuntime;
 
+/**
+ * Surface-scoped profile overlay — the seam letting any product page (a
+ * sequence editor, a brief composer, a dataset view) add MCP servers, a prompt
+ * addendum, and permission tightening to the workspace agent profile for turns
+ * initiated FROM that surface, without the chat orchestrator knowing any
+ * surface's specifics. The orchestrator resolves `(kind, ctx)` through a
+ * registry the REQUEST HANDLER constructs per request (construction is a Map
+ * build — cheap) and merges the result into the base profile it was about to
+ * send to the sandbox. Per-request construction is the trust mechanism, not an
+ * optimization target: each `build()` closes over server-trusted request state
+ * (env bindings, secrets, the AUTHENTICATED user/workspace), which on Workers
+ * exists only per request — a startup-built registry would force identity
+ * through the untrusted client `ctx`.
+ *
+ * SECURITY INVARIANT: the surface `kind` and the ids inside `ctx` arrive on
+ * the client request and are pure ROUTING data — never trusted content, never
+ * identity. Identity comes from the closure (see above). The registered
+ * `build()` runs server-side only: it validates the routing ids against the
+ * product's access control, then mints its own URLs and capability tokens from
+ * server configuration (`buildHttpMcpServer` + `createCapabilityToken` in
+ * ../tools). A client can therefore never inject an arbitrary MCP url, header,
+ * or token into the agent profile: the overlay's `mcp` values are typed as
+ * {@link SurfaceMcpServer} (= the server-built `AppToolMcpServer` entry shape),
+ * and only build() constructs them.
+ */
+
+/** Sandbox permission posture values, ranked deny > ask > allow for merging. */
+type SurfacePermissionValue = 'allow' | 'ask' | 'deny';
+/** The only MCP entry shape an overlay may carry: the server-built bridge
+ *  entry from ../tools/mcp (transport, url, headers, and capability token all
+ *  assembled server-side). The alias exists so overlay authors reach for the
+ *  builders in ../tools rather than hand-rolling `{ url: ctx.url }` shapes
+ *  that would let request data become a dialable endpoint. */
+type SurfaceMcpServer = AppToolMcpServer;
+/** What one surface contributes to the agent profile for a single turn. */
+interface SurfaceOverlay {
+    /** MCP servers to mount for this turn, keyed by tool-routing name. Names
+     *  must not collide with the base profile's — see {@link mergeSurfaceOverlay}. */
+    mcp?: Record<string, SurfaceMcpServer>;
+    /** Appended to the base system-prompt addendum with a blank-line separator. */
+    promptAddendum?: string;
+    /** Per-key posture the surface wants for its turns. Merging is monotone
+     *  fail-closed: the stricter of base/overlay wins, so a surface can tighten
+     *  the workspace posture but never relax it. */
+    permissions?: Record<string, SurfacePermissionValue>;
+}
+/**
+ * One registered surface kind. `TCtx` is the shape build() expects — a CLAIM
+ * about the client payload, not a guarantee: the registry hands build() the
+ * request's `ctx` unvalidated, so build() must treat every field as an
+ * untrusted id (resolve it through access control that throws on a bad or
+ * foreign id) before minting anything from it.
+ */
+interface SurfaceKindDefinition<TCtx> {
+    kind: string;
+    build: (ctx: TCtx) => SurfaceOverlay | Promise<SurfaceOverlay>;
+}
+/** The variance-erased form a registry accepts (`build` is contravariant in
+ *  `TCtx`, so every concrete definition is assignable to this). */
+type AnySurfaceKind = SurfaceKindDefinition<never>;
+/**
+ * Declare one surface kind. The `kind` string is the client-visible routing
+ * key (e.g. `'sequences'`); `build` is the server-side factory that turns a
+ * validated ctx into the overlay for one turn.
+ */
+declare function defineSurfaceKind<TCtx>(opts: {
+    kind: string;
+    build: (ctx: TCtx) => SurfaceOverlay | Promise<SurfaceOverlay>;
+}): SurfaceKindDefinition<TCtx>;
+interface SurfaceRegistry {
+    /** Build the overlay for one turn. Throws on an unknown kind — an unknown
+     *  surface is a routing bug (client and server registries drifted), and
+     *  silently returning an empty overlay would strip the surface's tools from
+     *  the turn with no signal anywhere. Build errors propagate unwrapped. */
+    resolve(kind: string, ctx: unknown): Promise<SurfaceOverlay>;
+}
+/**
+ * Assemble the product's surface registry from its registered kinds. Duplicate
+ * kinds throw at construction: two builders behind one routing key would make
+ * the mounted toolset depend on registration order.
+ */
+declare function createSurfaceRegistry(kinds: readonly AnySurfaceKind[]): SurfaceRegistry;
+/** Base-profile slice the merge reads/writes. Real callers pass their full
+ *  profile object; every field outside this slice passes through untouched. */
+interface SurfaceMergeBase {
+    mcp?: Record<string, unknown>;
+    systemPromptAddendum?: string;
+    permissions?: Record<string, SurfacePermissionValue>;
+}
+/**
+ * Merge one surface overlay into a base profile, returning a new object
+ * (the base is never mutated; untouched nested records are shared by
+ * reference).
+ *
+ * - `mcp`: overlay servers are added under their own names. A name already
+ *   present on the base THROWS — a collision is two servers claiming one
+ *   routing name, and renaming either silently would corrupt tool routing for
+ *   whichever caller expected the original binding.
+ * - `systemPromptAddendum`: the overlay's `promptAddendum` appends after a
+ *   blank-line separator (no separator when the base has no addendum).
+ * - `permissions`: per key the STRICTER value wins (deny > ask > allow). A
+ *   surface can tighten the base posture for its turns; a base 'deny' survives
+ *   any overlay.
+ */
+declare function mergeSurfaceOverlay<TBase extends SurfaceMergeBase>(base: TBase, overlay: SurfaceOverlay): TBase & SurfaceMergeBase;
+
 interface LoopToolCall {
     toolCallId?: string;
     toolName: string;
@@ -346,4 +453,4 @@ interface StreamAppToolLoopOptions<Raw> {
  */
 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, type ToolLoopStopReason, createAgentRuntime, createOpenAICompatStreamTurn, runAppToolLoop, streamAppToolLoop, toLoopEvents };
+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 };

package/dist/runtime/index.js

@@ -3,12 +3,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,
@@ -31,10 +34,13 @@ export {
   buildCatalog,
   createAgentRuntime,
   createOpenAICompatStreamTurn,
+  createSurfaceRegistry,
   createTangleRouterModelConfig,
+  defineSurfaceKind,
   fetchModelCatalog,
   isTangleBillingEnforcementDisabled,
   isTangleExecutionKeyError,
+  mergeSurfaceOverlay,
   normalizeModelId,
   resolveTangleExecutionEnvironment,
   resolveTangleModelConfig,