@tangle-network/agent-app 0.45.53 → 0.45.55

package/dist/{stream-normalizer-DKRxyVlZ.d.ts → stream/stream-normalizer.d.ts}

@@ -1,59 +1,58 @@
-import { a as ChatInteractionStatus } from './contract-OxG_jVMx.js';
-
+import { type ChatInteractionStatus } from '../interactions/contract';
 /** Represent a JSON-compatible object with string keys and values of any type */
-type JsonRecord = Record<string, unknown>;
+export type JsonRecord = Record<string, unknown>;
 /** Define an event object carrying a type and optional JSON data payload */
-interface StreamEvent {
+export interface StreamEvent {
     type: string;
     data?: JsonRecord;
 }
 /** Resolve an unknown value to a JsonRecord if it is a non-array object or return undefined */
-declare function asRecord(value: unknown): JsonRecord | undefined;
+export declare function asRecord(value: unknown): JsonRecord | undefined;
 /** Resolve a non-empty string from a value or return undefined */
-declare function asString(value: unknown): string | undefined;
+export declare function asString(value: unknown): string | undefined;
 /** Resolve a unique tool identifier from various possible properties or generate a fallback ID */
-declare function resolveToolId(part: JsonRecord): string;
+export declare function resolveToolId(part: JsonRecord): string;
 /** Resolve the tool name from a JSON record using tool, name, or a default value */
-declare function resolveToolName(part: JsonRecord): string;
+export declare function resolveToolName(part: JsonRecord): string;
 /** Resolve time properties from various keys into a normalized record with numeric start and end fields */
-declare function normalizeTime(value: unknown): JsonRecord | undefined;
+export declare function normalizeTime(value: unknown): JsonRecord | undefined;
 /** Normalize tool-related events into a standardized message.part.updated format */
-declare function normalizeToolEvent(event: StreamEvent): StreamEvent;
+export declare function normalizeToolEvent(event: StreamEvent): StreamEvent;
 /** Normalize a persisted part object by standardizing its structure and fields */
-declare function normalizePersistedPart(rawPart: JsonRecord): JsonRecord | null;
+export declare function normalizePersistedPart(rawPart: JsonRecord): JsonRecord | null;
 /** Stream/transcript part key for a promoted (path-bearing) attachment,
  *  keyed on its storage path — re-emitting the same path folds into the same
  *  segment instead of duplicating it. */
-declare function attachmentPartKey(path: string): string;
+export declare function attachmentPartKey(path: string): string;
 /** Resolve a unique key string for a part based on its type and identifying properties */
-declare function getPartKey(part: JsonRecord): string;
+export declare function getPartKey(part: JsonRecord): string;
 /** Merge incoming JSON with existing persisted data, applying delta for text types when provided */
-declare function mergePersistedPart(existing: JsonRecord | undefined, incoming: JsonRecord, delta?: string): JsonRecord;
+export declare function mergePersistedPart(existing: JsonRecord | undefined, incoming: JsonRecord, delta?: string): JsonRecord;
 /** Resolve errors when a tool fails to report a terminal result before the assistant turn ends */
-declare const MISSING_TOOL_TERMINAL_ERROR = "Tool did not report a terminal result before the assistant turn completed.";
+export declare const MISSING_TOOL_TERMINAL_ERROR = "Tool did not report a terminal result before the assistant turn completed.";
 /** Provide the reason identifier for a missing tool in the terminal environment */
-declare const MISSING_TOOL_TERMINAL_REASON = "missing-tool-terminal";
+export declare const MISSING_TOOL_TERMINAL_REASON = "missing-tool-terminal";
 /** Closes a tool part left `running` when a stream ended abnormally: settles
  *  it as a terminal `error` and stamps `state.metadata.terminalized` so the
  *  synthetic settlement is distinguishable from a real tool failure. Parts
  *  that already settled (and non-tool parts) pass through untouched. */
-declare function terminalizeDanglingToolPart(part: JsonRecord): JsonRecord;
+export declare function terminalizeDanglingToolPart(part: JsonRecord): JsonRecord;
 /** Resolve dangling tool parts into terminal forms within the given JSON records array */
-declare function terminalizeDanglingToolParts(parts: JsonRecord[]): JsonRecord[];
+export declare function terminalizeDanglingToolParts(parts: JsonRecord[]): JsonRecord[];
 /** Settles still-pending interaction parts at persist time. The broker
  *  guarantees a resolved question either answered (run unblocked, no cancel
  *  event) or cancelled/timed out (cancel event already updated the part), so
  *  the success path finalizes remaining pendings as `answered` and the
  *  failure/terminalize paths as `expired`. */
-declare function finalizePendingInteractionParts(parts: JsonRecord[], outcome: Extract<ChatInteractionStatus, 'answered' | 'expired'>): JsonRecord[];
+export declare function finalizePendingInteractionParts(parts: JsonRecord[], outcome: Extract<ChatInteractionStatus, 'answered' | 'expired'>): JsonRecord[];
 /** Collapses text-part artifacts of unstable upstream segment identity: the
  *  same text arriving under two keys (id-less delta stream, then an
  *  id-bearing snapshot) folds into two segments, and interleaved empty
  *  segments survive as blank parts. Consecutive identical text parts merge
  *  into one; empty text parts drop when any non-empty text part exists. */
-declare function collapseRedundantTextParts(parts: JsonRecord[]): JsonRecord[];
+export declare function collapseRedundantTextParts(parts: JsonRecord[]): JsonRecord[];
 /** Resolve and clean up assistant parts by terminalizing and collapsing redundant segments */
-declare function finalizeAssistantParts(partOrder: string[], partMap: Map<string, JsonRecord>, finalText: string): JsonRecord[];
+export declare function finalizeAssistantParts(partOrder: string[], partMap: Map<string, JsonRecord>, finalText: string): JsonRecord[];
 /** The MID-STREAM twin of {@link finalizeAssistantParts}: the same assembled,
  *  collapsed projection MINUS the dangling-tool terminalizer.
  *
@@ -70,12 +69,10 @@ declare function finalizeAssistantParts(partOrder: string[], partMap: Map<string
  *  Pending `interaction` parts are likewise left `pending` here (the caller
  *  skips {@link finalizePendingInteractionParts}) — an ask is genuinely
  *  unanswered until the turn settles. */
-declare function draftAssistantParts(partOrder: string[], partMap: Map<string, JsonRecord>, finalText: string): JsonRecord[];
+export declare function draftAssistantParts(partOrder: string[], partMap: Map<string, JsonRecord>, finalText: string): JsonRecord[];
 /** Finalizes, then folds each synthetic tool settlement back into `partMap`
  *  and returns just those updates — the shape a streaming loop needs to emit
  *  closing `message.part.updated` frames for tools the stream never settled. */
-declare function terminalizeDanglingAssistantToolUpdates(partOrder: string[], partMap: Map<string, JsonRecord>, finalText: string): JsonRecord[];
+export declare function terminalizeDanglingAssistantToolUpdates(partOrder: string[], partMap: Map<string, JsonRecord>, finalText: string): JsonRecord[];
 /** Encode a StreamEvent object into a Uint8Array using the provided TextEncoder */
-declare function encodeEvent(encoder: TextEncoder, event: StreamEvent): Uint8Array;
-
-export { type JsonRecord as J, MISSING_TOOL_TERMINAL_ERROR as M, type StreamEvent as S, attachmentPartKey as a, MISSING_TOOL_TERMINAL_REASON as b, asRecord as c, asString as d, collapseRedundantTextParts as e, draftAssistantParts as f, encodeEvent as g, finalizeAssistantParts as h, finalizePendingInteractionParts as i, getPartKey as j, normalizeTime as k, normalizeToolEvent as l, mergePersistedPart as m, normalizePersistedPart as n, resolveToolName as o, terminalizeDanglingToolPart as p, terminalizeDanglingToolParts as q, resolveToolId as r, terminalizeDanglingAssistantToolUpdates as t };
+export declare function encodeEvent(encoder: TextEncoder, event: StreamEvent): Uint8Array;

package/dist/{turn-buffer-COMQUwO2.d.ts → stream/turn-buffer.d.ts}

@@ -15,22 +15,22 @@
  * a flush window before they are persisted — replay yields slightly chunkier
  * deltas with identical concatenation.
  */
-type TurnStatus = 'running' | 'complete' | 'error';
+export type TurnStatus = 'running' | 'complete' | 'error';
 /** A running row is a renewable lease, not permanent truth. If the process
  *  driving a turn dies before writing a terminal status, reconnect discovery
  *  must eventually stop returning that abandoned row. */
-declare const DEFAULT_RUNNING_TURN_LEASE_MS: number;
+export declare const DEFAULT_RUNNING_TURN_LEASE_MS: number;
 /** Keep a healthy turn's lease comfortably ahead of expiry without turning
  *  per-token streaming into status-write traffic. */
-declare const DEFAULT_RUNNING_TURN_RENEW_INTERVAL_MS = 30000;
+export declare const DEFAULT_RUNNING_TURN_RENEW_INTERVAL_MS = 30000;
 /** Represent a buffered turn event with a sequence number and serialized event data */
-interface BufferedTurnEvent {
+export interface BufferedTurnEvent {
     seq: number;
     /** The serialized event line (JSON string, no trailing newline). */
     event: string;
 }
 /** Manage and query turn events and their lifecycle statuses within a scoped event store */
-interface TurnEventStore {
+export interface TurnEventStore {
     append(turnId: string, events: BufferedTurnEvent[]): Promise<void>;
     read(turnId: string, fromSeq: number): Promise<BufferedTurnEvent[]>;
     /** Record turn lifecycle. `scopeId` (a thread/session id) is optional and lets
@@ -47,14 +47,14 @@ interface TurnEventStore {
 /** Configure running-turn lease evaluation. The clock is injectable so store
  *  contract tests do not sleep. Keep the default in production unless a
  *  deployment also tunes the buffer's renewal interval. */
-interface TurnEventStoreOptions {
+export interface TurnEventStoreOptions {
     runningTurnLeaseMs?: number;
     now?: () => number;
 }
 /** Merge consecutive text/reasoning deltas of the same type into one event.
  *  Concatenation-preserving: replaying the coalesced stream produces the same
  *  accumulated text as the original. */
-declare function coalesceDeltas(events: unknown[]): unknown[];
+export declare function coalesceDeltas(events: unknown[]): unknown[];
 /**
  * Coalesce consecutive `message.part.updated` deltas for the SAME part into one
  * event. agent-runtime products stream `ChatStreamEvent` NDJSON
@@ -69,9 +69,9 @@ declare function coalesceDeltas(events: unknown[]): unknown[];
  * appends `delta` and one that reads the cumulative `part` both reconstruct the
  * identical final text.
  */
-declare function coalesceChatStreamEvents(events: unknown[]): unknown[];
+export declare function coalesceChatStreamEvents(events: unknown[]): unknown[];
 /** Define options for buffering and flushing turn events with optional live client delivery and event coalescing */
-interface BufferedTurnOptions {
+export interface BufferedTurnOptions {
     store: TurnEventStore;
     turnId: string;
     /** Deliver one serialized line to the live client. Throwing here (client
@@ -94,7 +94,7 @@ interface BufferedTurnOptions {
     runningTurnRenewIntervalMs?: number;
 }
 /** A push-driven buffer for a turn whose producer the caller does NOT own. */
-interface BufferedTurnTap {
+export interface BufferedTurnTap {
     /** Buffer one event: persist (coalesced, on the flush window) + best-effort
      *  live-deliver. Wire to a push source's per-event hook (e.g. agent-runtime
      *  `handleChatTurn`'s `hooks.onEvent`). Marks the turn 'running' on first call. */
@@ -114,9 +114,9 @@ interface BufferedTurnTap {
  *     + the finished body). Durability stays here in the shell; the engine needs
  *     no `TurnEventStore` seam.
  */
-declare function createBufferedTurnTap(opts: BufferedTurnOptions): BufferedTurnTap;
+export declare function createBufferedTurnTap(opts: BufferedTurnOptions): BufferedTurnTap;
 /** Define options to pump data from an asynchronous iterable source with buffered turn control */
-interface PumpBufferedTurnOptions extends BufferedTurnOptions {
+export interface PumpBufferedTurnOptions extends BufferedTurnOptions {
     source: AsyncIterable<unknown>;
 }
 /**
@@ -127,9 +127,9 @@ interface PumpBufferedTurnOptions extends BufferedTurnOptions {
  * client-write failure; a source error marks the turn 'error' (after flushing
  * what was produced) and rethrows.
  */
-declare function pumpBufferedTurn(opts: PumpBufferedTurnOptions): Promise<void>;
+export declare function pumpBufferedTurn(opts: PumpBufferedTurnOptions): Promise<void>;
 /** Define options for replaying turn events with control over sequence, polling, and timeout */
-interface ReplayTurnEventsOptions {
+export interface ReplayTurnEventsOptions {
     store: TurnEventStore;
     turnId: string;
     /** Replay strictly after this sequence number (0 = from the beginning). */
@@ -145,7 +145,7 @@ interface ReplayTurnEventsOptions {
  * final `{seq: -1, event: '{"type":"turn_status",...}'}` marker so clients
  * know why the replay ended.
  */
-declare function replayTurnEvents(opts: ReplayTurnEventsOptions): AsyncGenerator<BufferedTurnEvent>;
+export declare function replayTurnEvents(opts: ReplayTurnEventsOptions): AsyncGenerator<BufferedTurnEvent>;
 /**
  * Serialize a replayed row for the wire, stamping the buffer ordinal ONTO the
  * line so a reconnecting client can continue from `?fromSeq=<lastSeq>`.
@@ -166,9 +166,9 @@ declare function replayTurnEvents(opts: ReplayTurnEventsOptions): AsyncGenerator
  * verbatim. A stamping bug must degrade to today's behaviour, never break a
  * replay.
  */
-declare function stampReplaySeq(row: BufferedTurnEvent): string;
+export declare function stampReplaySeq(row: BufferedTurnEvent): string;
 /** Minimal structural D1 contract (Cloudflare `D1Database` satisfies it). */
-interface D1LikeForTurns {
+export interface D1LikeForTurns {
     prepare(sql: string): {
         bind(...values: unknown[]): {
             run(): Promise<unknown>;
@@ -180,14 +180,12 @@ interface D1LikeForTurns {
     };
 }
 /** Schema for the D1 store — append to the product's migrations. */
-declare const TURN_EVENTS_MIGRATION_SQL = "\nCREATE TABLE IF NOT EXISTS turn_events (\n  turnId TEXT NOT NULL,\n  seq INTEGER NOT NULL,\n  event TEXT NOT NULL,\n  PRIMARY KEY (turnId, seq)\n);\nCREATE TABLE IF NOT EXISTS turn_status (\n  turnId TEXT PRIMARY KEY,\n  status TEXT NOT NULL,\n  scopeId TEXT,\n  updatedAt TEXT NOT NULL\n);\nCREATE INDEX IF NOT EXISTS idx_turn_status_scope ON turn_status (scopeId, status);\n";
+export declare const TURN_EVENTS_MIGRATION_SQL = "\nCREATE TABLE IF NOT EXISTS turn_events (\n  turnId TEXT NOT NULL,\n  seq INTEGER NOT NULL,\n  event TEXT NOT NULL,\n  PRIMARY KEY (turnId, seq)\n);\nCREATE TABLE IF NOT EXISTS turn_status (\n  turnId TEXT PRIMARY KEY,\n  status TEXT NOT NULL,\n  scopeId TEXT,\n  updatedAt TEXT NOT NULL\n);\nCREATE INDEX IF NOT EXISTS idx_turn_status_scope ON turn_status (scopeId, status);\n";
 /** For deployments whose `turn_status` table predates `scopeId`/`listRunning` —
  *  run once to add the column (the CREATE above already includes it for new
  *  deployments). SQLite ignores a duplicate-add error if already applied. */
-declare const TURN_STATUS_SCOPE_MIGRATION_SQL = "ALTER TABLE turn_status ADD COLUMN scopeId TEXT;";
+export declare const TURN_STATUS_SCOPE_MIGRATION_SQL = "ALTER TABLE turn_status ADD COLUMN scopeId TEXT;";
 /** Resolve a TurnEventStore that appends and reads turn events using a D1-like database interface */
-declare function createD1TurnEventStore(db: D1LikeForTurns, options?: TurnEventStoreOptions): TurnEventStore;
+export declare function createD1TurnEventStore(db: D1LikeForTurns, options?: TurnEventStoreOptions): TurnEventStore;
 /** In-memory store for tests and keyless local dev. */
-declare function createMemoryTurnEventStore(options?: TurnEventStoreOptions): TurnEventStore;
-
-export { type BufferedTurnEvent as B, type D1LikeForTurns as D, type PumpBufferedTurnOptions as P, type ReplayTurnEventsOptions as R, type TurnEventStore as T, type BufferedTurnOptions as a, type BufferedTurnTap as b, DEFAULT_RUNNING_TURN_LEASE_MS as c, DEFAULT_RUNNING_TURN_RENEW_INTERVAL_MS as d, TURN_EVENTS_MIGRATION_SQL as e, TURN_STATUS_SCOPE_MIGRATION_SQL as f, type TurnEventStoreOptions as g, type TurnStatus as h, coalesceChatStreamEvents as i, coalesceDeltas as j, createBufferedTurnTap as k, createD1TurnEventStore as l, createMemoryTurnEventStore as m, pumpBufferedTurn as p, replayTurnEvents as r, stampReplaySeq as s };
+export declare function createMemoryTurnEventStore(options?: TurnEventStoreOptions): TurnEventStore;

package/dist/stream/turn-identity.d.ts

@@ -0,0 +1,49 @@
+import type { JsonRecord } from './stream-normalizer';
+/** Define the structure of a chat message stored for a specific conversation turn */
+export interface PersistedChatMessageForTurn {
+    id: string;
+    role: 'user' | 'assistant' | 'system' | 'tool';
+    content: string;
+    parts: Array<Record<string, unknown>> | null;
+}
+/** Represent a chat turn with resolved user message insertion and prior message context */
+export interface ResolvedChatTurn {
+    turnIndex: number;
+    shouldInsertUserMessage: boolean;
+    priorMessages: PersistedChatMessageForTurn[];
+    userParts: JsonRecord[];
+    /** The id of the user row this turn REUSES (retry dedup), when one was
+     *  found. Absent on the insert path, where no row exists yet.
+     *
+     *  The reused row is deliberately EXCLUDED from `priorMessages` (it is this
+     *  turn's own user message, not prior context), so this field is the only
+     *  way a caller can name it. */
+    reusedUserMessageId?: string;
+}
+/** Normalize and validate a client turn ID string ensuring it meets format and length requirements */
+export declare function normalizeClientTurnId(value: unknown): string | undefined;
+/** Build an array of text parts with optional turn ID for user input */
+export declare function buildUserTextParts(text: string, turnId: string | undefined): JsonRecord[];
+/** Resolve whether a message contains any part with the specified turn ID */
+export declare function messageHasTurnId(message: PersistedChatMessageForTurn, turnId: string): boolean;
+/** Resolve a chat turn by determining message reuse and constructing user message parts */
+export declare function resolveChatTurn(input: {
+    existingMessages: PersistedChatMessageForTurn[];
+    userContent: string;
+    turnId?: string;
+    /** True when the thread has a turn still RUNNING in the turn-event buffer
+     *  (`turnStore.listRunning(threadId)`).
+     *
+     *  Without incremental persistence the trailing row of a thread mid-turn is
+     *  always the user row, so the content fallback below could assume it. With
+     *  incremental persistence the assistant row lands seconds into the turn, so
+     *  a retry of that same turn finds an ASSISTANT row trailing and would
+     *  insert a duplicate user row.
+     *
+     *  This flag is the discriminator that keeps both cases right, and it needs
+     *  no new state: an assistant row trailing a turn that is still running is
+     *  that turn's in-flight draft (walk past it — this is a retry), whereas an
+     *  assistant row trailing a SETTLED turn is a completed answer (stop — the
+     *  user genuinely repeated a message and deserves a new turn). */
+    hasRunningTurn?: boolean;
+}): ResolvedChatTurn;

package/dist/studio/generation.d.ts

@@ -0,0 +1,179 @@
+/** Define the structure for a studio integration connection with status and provider identifiers */
+export interface StudioIntegrationConnection {
+    status: string;
+    providerId: string;
+    connectorId?: string;
+}
+/** Define generation categories for media including image, video, speech, avatar, and transcription */
+export type GenerationType = 'image' | 'video' | 'speech' | 'avatar' | 'transcription';
+/** Define possible states representing the progress of a generation process */
+export type GenerationStatus = 'pending' | 'running' | 'succeeded' | 'failed';
+/** Define possible status values for a media model's availability and accessibility */
+export type MediaModelStatus = 'available' | 'limited' | 'unavailable';
+/** Define the structure for a generation entity including its metadata and creation details */
+export interface Generation {
+    id: string;
+    type: string;
+    prompt: string;
+    result: string | null;
+    model: string | null;
+    cost: number | null;
+    createdAt: Date | null;
+    metadata: Record<string, unknown> | null;
+}
+/** Describe media model option properties including id, name, type, status, and optional provider and reason */
+export interface MediaModelOption {
+    id: string;
+    name: string;
+    provider?: string;
+    type: GenerationType;
+    status: MediaModelStatus;
+    reason?: string;
+}
+/** Represent media model catalog with default values, model options, and optional error message */
+export interface MediaModelCatalogResponse {
+    defaults: Record<GenerationType, string>;
+    models: Record<GenerationType, MediaModelOption[]>;
+    error?: string;
+}
+/** Define the structure for configuring package publishing details and evaluation criteria */
+export interface PublishPackage {
+    caption: string;
+    description: string;
+    mentions: string[];
+    destinations: string[];
+    cadence: string;
+    workflowDraft: boolean;
+    evalContract: {
+        artifactType: string;
+        deterministicChecks: string[];
+    };
+}
+/** Define a destination for publishing content with identifiers, label, provider IDs, and fields */
+export interface PublishDestination {
+    id: string;
+    label: string;
+    providerIds: string[];
+    fields: string;
+}
+/** Provide an array of supported generation types for media and content processing */
+export declare const GENERATION_TYPES: readonly GenerationType[];
+/** Resolve whether a string value matches a valid GenerationType */
+export declare function isGenerationType(value: string): value is GenerationType;
+/** List available social media platforms with their publishing fields and provider identifiers */
+export declare const DESTINATIONS: PublishDestination[];
+/** Provide an array of predefined cadence options for scheduling or approval processes */
+export declare const CADENCES: string[];
+/** Provide the valid image quality values for generation requests */
+export declare const IMAGE_QUALITIES: readonly ["low", "medium", "high", "auto"];
+/** Provide a placeholder hint listing the accepted image size values */
+export declare const IMAGE_SIZE_HINT = "1024x1024, 1536x1024, 1024x1536, or auto";
+/** Provide a validation pattern for the free-form image size field (WxH or auto) */
+export declare const IMAGE_SIZE_PATTERN: string;
+/** Provide the valid video duration values (seconds) for generation requests */
+export declare const VIDEO_DURATIONS: readonly ["4", "6", "8", "10", "12"];
+/** Provide the valid video resolution values for generation requests */
+export declare const VIDEO_RESOLUTIONS: readonly ["720p", "1080p"];
+/** Provide the valid video aspect ratio values for generation requests */
+export declare const VIDEO_ASPECT_RATIOS: readonly ["16:9", "9:16", "1:1"];
+/** Define the minimum number of images required for processing or validation */
+export declare const MIN_IMAGE_COUNT = 1;
+/** Define the maximum number of images allowed for upload or display */
+export declare const MAX_IMAGE_COUNT = 4;
+/** Resolve a human-readable relative time string from a given date or return an empty string if null */
+export declare function relativeTime(date: Date | null): string;
+/** Resolve the output directory path based on the specified generation type */
+export declare function outputPathFor(type: GenerationType): string;
+/** Resolve the vault path string from a Generation object or return null if unavailable */
+export declare function generationVaultPath(generation: Generation): string | null;
+/** Build a PublishPackage object from caption, description, mentions, cadence, and destinations inputs */
+export declare function buildPublishPackage({ caption, postDescription, mentions, cadence, destinations, }: {
+    caption: string;
+    postDescription: string;
+    mentions: string;
+    cadence: string;
+    destinations: string[];
+}): PublishPackage | null;
+/** Determine if a value conforms to the PublishPackage structure with optional metadata fields */
+export declare function isPublishPackage(value: unknown): value is {
+    caption?: string;
+    description?: string;
+    mentions?: string[];
+    destinations?: string[];
+    cadence?: string;
+};
+/** Determine if a destination has any active connections in the given list of studio integration connections */
+export declare function isDestinationConnected(destination: PublishDestination, connections: StudioIntegrationConnection[]): boolean;
+/** Resolve selected models by applying defaults for missing or unavailable entries in the catalog */
+export declare function selectedModelsWithDefaults(current: Partial<Record<GenerationType, string>>, catalog: MediaModelCatalogResponse): Partial<Record<GenerationType, string>>;
+/** Resolve the preferred model ID for a given generation type from the media model catalog */
+export declare function preferredModelId(type: GenerationType, catalog: MediaModelCatalogResponse | null): string | undefined;
+/** Resolve the appropriate status message for a media model based on loading state and availability */
+export declare function modelMessage(model: MediaModelOption | undefined, loading: boolean, count: number): string | null;
+/** Define fields required to configure and request various types of media generation */
+export interface GenerationRequestFields {
+    workspaceId: string;
+    clientRequestId: string;
+    type: GenerationType;
+    model: string;
+    prompt: string;
+    negativePrompt: string;
+    outputPath: string;
+    publishPackage: PublishPackage | null;
+    image: {
+        size: string;
+        quality: string;
+        count: number;
+    };
+    video: {
+        duration: string;
+        resolution: string;
+        aspectRatio: string;
+        referenceImageUrl: string;
+    };
+    speech: {
+        voice: string;
+    };
+    avatar: {
+        audioUrl: string;
+        imageUrl: string;
+        avatarId: string;
+    };
+    transcription: {
+        audioUrl: string;
+        language: string;
+        responseFormat: string;
+        temperature: string;
+    };
+}
+/** Build the request body object for a generation operation from provided fields */
+export declare function buildGenerationRequestBody(fields: GenerationRequestFields): Record<string, unknown>;
+/** Resolve the current status of a generation based on its metadata and result fields */
+export declare function generationStatus(generation: Generation): GenerationStatus;
+/** Resolve and return the first user-safe error message from generation metadata or null if none exist */
+export declare function generationError(generation: Generation): string | null;
+/** Resolve a unique merge key from a generation using batch slot or client request ID */
+export declare function generationMergeKey(generation: Generation): string | null;
+/** Merge a new generation into the current list by replacing or prepending it based on matching keys */
+export declare function mergeLiveGeneration(current: Generation[], generation: Generation): Generation[];
+/** Merge two Generation arrays prioritizing live entries and matching by merge keys or IDs */
+export declare function mergeLoaderAndLive(loader: Generation[], live: Generation[]): Generation[];
+/** Determine if a generation ID indicates a local generation */
+export declare function isLocalGeneration(generation: Generation): boolean;
+/** Resolve and return the latest batch of generations grouped and sorted by client request ID and output index */
+export declare function latestBatchOf(generations: Generation[]): Generation[];
+/** Resolve a user-safe generation message by filtering sensitive or error-related content */
+export declare function userSafeGenerationMessage(message?: string): string;
+/** Generate content optimistically based on input parameters and optional model and output details */
+export declare function optimisticGeneration({ type, prompt, model, clientRequestId, outputIndex, outputCount, }: {
+    type: GenerationType;
+    prompt: string;
+    model?: string;
+    clientRequestId: string;
+    outputIndex?: number;
+    outputCount?: number;
+}): Generation;
+/** Mark a generation as failed with updated status and error information */
+export declare function failedOptimisticGeneration(generation: Generation): Generation;
+/** Normalize a value to a finite integer within the allowed image count range */
+export declare function normalizeImageCount(value: unknown): number;

package/dist/studio/index.d.ts

@@ -1,181 +1,12 @@
-/** Define the structure for a studio integration connection with status and provider identifiers */
-interface StudioIntegrationConnection {
-    status: string;
-    providerId: string;
-    connectorId?: string;
-}
-/** Define generation categories for media including image, video, speech, avatar, and transcription */
-type GenerationType = 'image' | 'video' | 'speech' | 'avatar' | 'transcription';
-/** Define possible states representing the progress of a generation process */
-type GenerationStatus = 'pending' | 'running' | 'succeeded' | 'failed';
-/** Define possible status values for a media model's availability and accessibility */
-type MediaModelStatus = 'available' | 'limited' | 'unavailable';
-/** Define the structure for a generation entity including its metadata and creation details */
-interface Generation {
-    id: string;
-    type: string;
-    prompt: string;
-    result: string | null;
-    model: string | null;
-    cost: number | null;
-    createdAt: Date | null;
-    metadata: Record<string, unknown> | null;
-}
-/** Describe media model option properties including id, name, type, status, and optional provider and reason */
-interface MediaModelOption {
-    id: string;
-    name: string;
-    provider?: string;
-    type: GenerationType;
-    status: MediaModelStatus;
-    reason?: string;
-}
-/** Represent media model catalog with default values, model options, and optional error message */
-interface MediaModelCatalogResponse {
-    defaults: Record<GenerationType, string>;
-    models: Record<GenerationType, MediaModelOption[]>;
-    error?: string;
-}
-/** Define the structure for configuring package publishing details and evaluation criteria */
-interface PublishPackage {
-    caption: string;
-    description: string;
-    mentions: string[];
-    destinations: string[];
-    cadence: string;
-    workflowDraft: boolean;
-    evalContract: {
-        artifactType: string;
-        deterministicChecks: string[];
-    };
-}
-/** Define a destination for publishing content with identifiers, label, provider IDs, and fields */
-interface PublishDestination {
-    id: string;
-    label: string;
-    providerIds: string[];
-    fields: string;
-}
-/** Provide an array of supported generation types for media and content processing */
-declare const GENERATION_TYPES: readonly GenerationType[];
-/** Resolve whether a string value matches a valid GenerationType */
-declare function isGenerationType(value: string): value is GenerationType;
-/** List available social media platforms with their publishing fields and provider identifiers */
-declare const DESTINATIONS: PublishDestination[];
-/** Provide an array of predefined cadence options for scheduling or approval processes */
-declare const CADENCES: string[];
-/** Provide the valid image quality values for generation requests */
-declare const IMAGE_QUALITIES: readonly ["low", "medium", "high", "auto"];
-/** Provide a placeholder hint listing the accepted image size values */
-declare const IMAGE_SIZE_HINT = "1024x1024, 1536x1024, 1024x1536, or auto";
-/** Provide a validation pattern for the free-form image size field (WxH or auto) */
-declare const IMAGE_SIZE_PATTERN: string;
-/** Provide the valid video duration values (seconds) for generation requests */
-declare const VIDEO_DURATIONS: readonly ["4", "6", "8", "10", "12"];
-/** Provide the valid video resolution values for generation requests */
-declare const VIDEO_RESOLUTIONS: readonly ["720p", "1080p"];
-/** Provide the valid video aspect ratio values for generation requests */
-declare const VIDEO_ASPECT_RATIOS: readonly ["16:9", "9:16", "1:1"];
-/** Define the minimum number of images required for processing or validation */
-declare const MIN_IMAGE_COUNT = 1;
-/** Define the maximum number of images allowed for upload or display */
-declare const MAX_IMAGE_COUNT = 4;
-/** Resolve a human-readable relative time string from a given date or return an empty string if null */
-declare function relativeTime(date: Date | null): string;
-/** Resolve the output directory path based on the specified generation type */
-declare function outputPathFor(type: GenerationType): string;
-/** Resolve the vault path string from a Generation object or return null if unavailable */
-declare function generationVaultPath(generation: Generation): string | null;
-/** Build a PublishPackage object from caption, description, mentions, cadence, and destinations inputs */
-declare function buildPublishPackage({ caption, postDescription, mentions, cadence, destinations, }: {
-    caption: string;
-    postDescription: string;
-    mentions: string;
-    cadence: string;
-    destinations: string[];
-}): PublishPackage | null;
-/** Determine if a value conforms to the PublishPackage structure with optional metadata fields */
-declare function isPublishPackage(value: unknown): value is {
-    caption?: string;
-    description?: string;
-    mentions?: string[];
-    destinations?: string[];
-    cadence?: string;
-};
-/** Determine if a destination has any active connections in the given list of studio integration connections */
-declare function isDestinationConnected(destination: PublishDestination, connections: StudioIntegrationConnection[]): boolean;
-/** Resolve selected models by applying defaults for missing or unavailable entries in the catalog */
-declare function selectedModelsWithDefaults(current: Partial<Record<GenerationType, string>>, catalog: MediaModelCatalogResponse): Partial<Record<GenerationType, string>>;
-/** Resolve the preferred model ID for a given generation type from the media model catalog */
-declare function preferredModelId(type: GenerationType, catalog: MediaModelCatalogResponse | null): string | undefined;
-/** Resolve the appropriate status message for a media model based on loading state and availability */
-declare function modelMessage(model: MediaModelOption | undefined, loading: boolean, count: number): string | null;
-/** Define fields required to configure and request various types of media generation */
-interface GenerationRequestFields {
-    workspaceId: string;
-    clientRequestId: string;
-    type: GenerationType;
-    model: string;
-    prompt: string;
-    negativePrompt: string;
-    outputPath: string;
-    publishPackage: PublishPackage | null;
-    image: {
-        size: string;
-        quality: string;
-        count: number;
-    };
-    video: {
-        duration: string;
-        resolution: string;
-        aspectRatio: string;
-        referenceImageUrl: string;
-    };
-    speech: {
-        voice: string;
-    };
-    avatar: {
-        audioUrl: string;
-        imageUrl: string;
-        avatarId: string;
-    };
-    transcription: {
-        audioUrl: string;
-        language: string;
-        responseFormat: string;
-        temperature: string;
-    };
-}
-/** Build the request body object for a generation operation from provided fields */
-declare function buildGenerationRequestBody(fields: GenerationRequestFields): Record<string, unknown>;
-/** Resolve the current status of a generation based on its metadata and result fields */
-declare function generationStatus(generation: Generation): GenerationStatus;
-/** Resolve and return the first user-safe error message from generation metadata or null if none exist */
-declare function generationError(generation: Generation): string | null;
-/** Resolve a unique merge key from a generation using batch slot or client request ID */
-declare function generationMergeKey(generation: Generation): string | null;
-/** Merge a new generation into the current list by replacing or prepending it based on matching keys */
-declare function mergeLiveGeneration(current: Generation[], generation: Generation): Generation[];
-/** Merge two Generation arrays prioritizing live entries and matching by merge keys or IDs */
-declare function mergeLoaderAndLive(loader: Generation[], live: Generation[]): Generation[];
-/** Determine if a generation ID indicates a local generation */
-declare function isLocalGeneration(generation: Generation): boolean;
-/** Resolve and return the latest batch of generations grouped and sorted by client request ID and output index */
-declare function latestBatchOf(generations: Generation[]): Generation[];
-/** Resolve a user-safe generation message by filtering sensitive or error-related content */
-declare function userSafeGenerationMessage(message?: string): string;
-/** Generate content optimistically based on input parameters and optional model and output details */
-declare function optimisticGeneration({ type, prompt, model, clientRequestId, outputIndex, outputCount, }: {
-    type: GenerationType;
-    prompt: string;
-    model?: string;
-    clientRequestId: string;
-    outputIndex?: number;
-    outputCount?: number;
-}): Generation;
-/** Mark a generation as failed with updated status and error information */
-declare function failedOptimisticGeneration(generation: Generation): Generation;
-/** Normalize a value to a finite integer within the allowed image count range */
-declare function normalizeImageCount(value: unknown): number;
-
-export { CADENCES, DESTINATIONS, GENERATION_TYPES, type Generation, type GenerationRequestFields, type GenerationStatus, type GenerationType, IMAGE_QUALITIES, IMAGE_SIZE_HINT, IMAGE_SIZE_PATTERN, MAX_IMAGE_COUNT, MIN_IMAGE_COUNT, type MediaModelCatalogResponse, type MediaModelOption, type MediaModelStatus, type PublishDestination, type PublishPackage, type StudioIntegrationConnection, VIDEO_ASPECT_RATIOS, VIDEO_DURATIONS, VIDEO_RESOLUTIONS, buildGenerationRequestBody, buildPublishPackage, failedOptimisticGeneration, generationError, generationMergeKey, generationStatus, generationVaultPath, isDestinationConnected, isGenerationType, isLocalGeneration, isPublishPackage, latestBatchOf, mergeLiveGeneration, mergeLoaderAndLive, modelMessage, normalizeImageCount, optimisticGeneration, outputPathFor, preferredModelId, relativeTime, selectedModelsWithDefaults, userSafeGenerationMessage };
+/**
+ * Studio module: the generation model and the pure helpers a media-generation
+ * surface needs — the `Generation` row shape and its lifecycle status/error
+ * derivation, the optimistic + live-merge logic that backs polling, the media
+ * model catalog types + selection helpers, the request-body builder, and the
+ * publish-package model.
+ *
+ * Logic only — no React, no DOM, no design-system import. Safe in server
+ * bundles. The React surface (composer, result canvas, library drawer, the
+ * `StudioWorkspace` shell) lives in `@tangle-network/agent-app/studio-react`.
+ */
+export * from './generation';