@tangle-network/agent-app 0.43.43 → 0.43.44

package/dist/file-index-Bw_IQE_G.d.ts

@@ -1,194 +0,0 @@
-/**
- * Wire contract between the chat client (composer + `streamChatTurn`) and the
- * assembled server vertical (`createChatTurnRoutes`). Import-free on purpose:
- * `/web-react` re-exports these types into browser bundles, so nothing here may
- * reach a Node builtin or an engine package.
- *
- * The part shape mirrors the sandbox SDK's `PromptInputPart` structurally
- * (text | image | file with filename/mediaType/url/path/content) — derived
- * here, not imported, so the client bundle never touches the SDK.
- */
-interface ChatTurnTextPartInput {
-    type: 'text';
-    text: string;
-}
-/** A non-text prompt part the upload route hands back and the client echoes
- *  on send. `url` carries an inline `data:` URI for small files; `path` is a
- *  sandbox workspace reference for large ones (the >1 MiB gateway body cap
- *  makes the two-step upload mandatory). */
-interface ChatTurnFilePartInput {
-    type: 'image' | 'file';
-    filename?: string;
-    mediaType?: string;
-    url?: string;
-    path?: string;
-    content?: string;
-}
-type ChatTurnPartInput = ChatTurnTextPartInput | ChatTurnFilePartInput;
-/** POST body for the turn route. `content` may be empty when `parts` carry the
- *  message (an image-only send). Product routing fields (workspaceId etc.) ride
- *  alongside and are read by the product's `authorize` seam. */
-interface ChatTurnRequestPayload {
-    threadId: string;
-    content?: string;
-    /** Non-text parts from the upload route, echoed back verbatim. */
-    parts?: ChatTurnFilePartInput[];
-    model?: string;
-    effort?: 'auto' | 'low' | 'medium' | 'high';
-    harness?: string;
-    /** Client-generated idempotency key for the logical turn (retry-safe). */
-    turnId?: string;
-    [key: string]: unknown;
-}
-/** `fetch` init for the turn route — the one place the client wire shape is
- *  serialized, so composer glue and products never drift from the server's
- *  parser. */
-declare function chatTurnRequestInit(payload: ChatTurnRequestPayload): RequestInit;
-declare const INLINE_PARTS_MAX_BYTES = 950000;
-declare class ChatTurnInputError extends Error {
-    readonly status: number;
-    readonly code: string;
-    constructor(message: string, status?: number, code?: string);
-}
-declare function promptPartsByteSize(parts: ChatTurnPartInput[]): number;
-/** Throws `ChatTurnInputError` (413) when the parts' inline payload would blow
- *  the gateway cap. Path-ref parts are tiny by construction and always pass. */
-declare function assertPromptPartsWithinCap(parts: ChatTurnPartInput[], maxBytes?: number): void;
-/** A file mention resolved from the composer's `@`-picker: the
- *  workspace-relative path plus enough metadata to build a prompt part and
- *  pointer text. `path` is the canonical identity — the mention pill's
- *  `MentionItem.id` for the file kind (`/web-react`'s `useFileMentions`). */
-interface FileMention {
-    path: string;
-    name: string;
-    size?: number;
-}
-/** The `image/*` mime for a mention path by extension, or `undefined` for
- *  anything not in the known image set (dispatched as `type: 'file'`). */
-declare function mediaTypeForMentionPath(path: string): string | undefined;
-interface FileMentionsToPartsOptions {
-    /** Resolve a mention's workspace-relative path to the absolute path the
-     *  dispatched part should carry (e.g. a host prefixing the in-box vault
-     *  root). Default: identity — the path travels unchanged. */
-    resolvePath?: (path: string) => string;
-}
-/** Maps resolved file mentions to path-only `ChatTurnFilePartInput`s —
- *  `image` vs `file` by extension, and always a `path`, never a `url` (the
- *  url/path XOR invariant: a mention is a sandbox path reference, never
- *  inline bytes). */
-declare function fileMentionsToParts(mentions: readonly FileMention[], opts?: FileMentionsToPartsOptions): ChatTurnFilePartInput[];
-/** The agent-facing pointer block appended to the dispatched prompt — never
- *  persisted in message `content`. Empty array → `''` so callers can append
- *  unconditionally. This is the sole producer of that text: the current
- *  turn's dispatch and any history projection built from the same mention
- *  list both route through here, so the two can't drift apart. */
-declare function buildMentionPromptBlock(mentions: readonly Pick<FileMention, 'name' | 'path'>[]): string;
-/** Validates the untyped `parts` array off the wire. Returns the typed parts
- *  or throws `ChatTurnInputError` (400) naming the offending entry. */
-declare function parseChatTurnParts(raw: unknown): ChatTurnFilePartInput[];
-
-/**
- * `createSandboxFileIndexRoute` — server side of `@`-file-mentions
- * (companion to sandbox-ui#184's composer mention primitive). Serves a flat,
- * ignore-filtered listing of the workspace sandbox so `useFileMentions`
- * (`/web-react`) can filter it client-side without a round trip per
- * keystroke.
- *
- * Same seam style as `createUploadRoute`: `authorize({ request })` resolves a
- * structural `{ tree(path, opts) }` handle (the shape of the sandbox SDK's
- * `box.fs.tree`) — no SDK import here. `authorize` also carries the
- * cold-box signal: a sandbox that isn't running yet answers `{ status:
- * 'warming' }` directly, never provisions-and-waits inside this route.
- */
-
-/** One entry from a structural `tree()` scan. Mirrors the sandbox SDK's
- *  `FileTreeFile` (`path`, `size`, `mtime`) — `mtime` is unused here so it's
- *  omitted from the structural match. */
-interface SandboxTreeFile {
-    path: string;
-    size: number;
-}
-/** Structural match of the sandbox SDK's `box.fs.tree` result shape
- *  (`FileTreeResult`). `stats.truncated` is the only stat this route reads;
- *  the rest ride through unread on the real SDK type. */
-interface SandboxTreeResult {
-    root: string;
-    files: SandboxTreeFile[];
-    stats: {
-        truncated: boolean;
-    };
-}
-/** Structural match of the sandbox SDK's `box.fs` tree surface. */
-interface SandboxFileTreeSource {
-    tree(path: string, options?: {
-        maxDepth?: number;
-    }): Promise<SandboxTreeResult>;
-}
-interface FileIndexReadyResponse {
-    status: 'ready';
-    /** Workspace-relative entries. Same shape as `FileMention` (`./wire`) so a
-     *  client can hand a response entry straight to `fileMentionsToParts` /
-     *  `buildMentionPromptBlock` without remapping. */
-    files: FileMention[];
-    /** True when either the underlying scan truncated (SDK-side cap) or this
-     *  route's own `maxEntries` cap trimmed the filtered list. The client
-     *  should show "showing first N files" rather than imply completeness. */
-    truncated: boolean;
-    generatedAt: string;
-}
-/** Cold-box answer: no provisioning happened, no files were scanned. The
- *  client shows a warming state and retries — this route never blocks on a
- *  box coming up. */
-interface FileIndexWarmingResponse {
-    status: 'warming';
-}
-type FileIndexResponse = FileIndexReadyResponse | FileIndexWarmingResponse;
-/** Short-TTL cache seam so repeat popover opens in the same session don't
- *  re-scan the workspace. Host-provided (e.g. a KV binding); `key` is
- *  whatever `authorize` returns as `cacheKey` — this route treats it opaquely. */
-interface FileIndexCache {
-    get(key: string): Promise<FileIndexReadyResponse | null> | FileIndexReadyResponse | null;
-    put(key: string, value: FileIndexReadyResponse, options?: {
-        ttlSeconds?: number;
-    }): Promise<void> | void;
-}
-type FileIndexAuthorization = {
-    status: 'ready';
-    /** Structural sandbox `fs` handle, usually `ensureWorkspaceSandbox(...)` → `box.fs`. */
-    fs: SandboxFileTreeSource;
-    /** Workspace root to index (e.g. `/home/agent`). */
-    root: string;
-    /** Extra ignore segments for this request, merged with the route's
-     *  defaults + `CreateSandboxFileIndexRouteOptions.ignore`. */
-    ignore?: string[];
-    /** Opaque cache key for the optional cache seam. Omit to skip caching
-     *  for this request (e.g. a workspace the host chooses not to cache). */
-    cacheKey?: string;
-} | {
-    status: 'warming';
-} | {
-    status: 'denied';
-    response: Response;
-};
-interface CreateSandboxFileIndexRouteOptions {
-    /** Authenticate the caller, resolve the sandbox `fs` handle, and signal a
-     *  cold box — never provisions or waits. */
-    authorize(args: {
-        request: Request;
-    }): Promise<FileIndexAuthorization>;
-    /** Extra ignore segments beyond the route's defaults (node_modules, .git,
-     *  dotfiles/dot-dirs, common build dirs). Matched as exact path-segment
-     *  names, same rule as the defaults. */
-    ignore?: string[];
-    /** Passed to `fs.tree` as `options.maxDepth`. Default 12. */
-    maxDepth?: number;
-    /** Hard cap on entries returned after filtering. Default 5000. */
-    maxEntries?: number;
-    /** Optional host-provided cache seam. */
-    cache?: FileIndexCache;
-    /** Cache TTL in seconds when `cache` is set. Default 20. */
-    cacheTtlSeconds?: number;
-}
-declare function createSandboxFileIndexRoute(options: CreateSandboxFileIndexRouteOptions): (request: Request) => Promise<Response>;
-
-export { type ChatTurnRequestPayload as C, type FileIndexAuthorization as F, INLINE_PARTS_MAX_BYTES as I, type SandboxFileTreeSource as S, type ChatTurnPartInput as a, type ChatTurnFilePartInput as b, ChatTurnInputError as c, type ChatTurnTextPartInput as d, type CreateSandboxFileIndexRouteOptions as e, type FileIndexCache as f, type FileIndexReadyResponse as g, type FileIndexResponse as h, type FileIndexWarmingResponse as i, type FileMention as j, type FileMentionsToPartsOptions as k, type SandboxTreeFile as l, type SandboxTreeResult as m, assertPromptPartsWithinCap as n, buildMentionPromptBlock as o, chatTurnRequestInit as p, createSandboxFileIndexRoute as q, fileMentionsToParts as r, mediaTypeForMentionPath as s, parseChatTurnParts as t, promptPartsByteSize as u };

package/dist/parts-DjX0RRTS.d.ts

@@ -1,182 +0,0 @@
-import { Part } from '@tangle-network/agent-interface';
-import { a as ChatInteractionField, b as ChatInteractionStatus, h as InteractionAnswers, N as NoticeKind } from './contract-KfqJh_au.js';
-import { ChatPlanPersistedPart } from './plans/index.js';
-
-/**
- * The stored shape of `message.parts` — one typed vocabulary for every part a
- * product persists into a chat transcript. NOT an ad-hoc union reverse-
- * engineered from product schemas; each member is matched field-for-field to
- * its canonical source:
- *
- * - `text` / `reasoning` / `tool`: the persisted projection `/stream`'s
- *   `normalizePersistedPart` produces from the harness lane's
- *   `message.part.updated` events (ADC sidecar
- *   `apps/sidecar/src/events/session-events.ts:56` wraps the canonical part in
- *   an `{id, sessionID, messageID}` envelope; the projection strips the
- *   session/message ids and keeps the per-segment part id).
- * - `file` / `image` / `step-start` / `step-finish`: the sidecar's canonical
- *   `MessagePartSchema` members (ADC
- *   `apps/sidecar/src/schemas/agent-schemas.ts:50-154`); `step-finish` carries
- *   the harness's per-step usage receipt — tokens
- *   `{total, input, output, reasoning, cache{write, read}}` + `cost` — which is
- *   also the shape the message-level token/cost columns mirror.
- * - `subtask`: `@tangle-network/agent-interface`'s `SubtaskPart` (a spawned
- *   sub-agent task).
- * - `interaction` / `notice`: the persisted-part codecs in
- *   `/web-react`'s chat-interactions contract (`interactionToPersistedPart`,
- *   `noticePart`) — type-only imports, one source of truth for their statuses
- *   and field shapes.
- * - `plan`: the durable-plan projection in `/plans`, derived from the sandbox
- *   SDK's authoritative plan lifecycle.
- *
- * `@tangle-network/agent-interface` exports the canonical wire `Part` union,
- * but its `PartBase` requires the `sessionID`/`messageID` stream envelope that
- * is deliberately NOT persisted, so the stored union is defined here as the
- * envelope-free projection (a type-level coverage check against the peer's
- * `Part['type']` lives in the tests). Contribute-down candidate: if
- * agent-interface grows envelope-free persisted-part types, re-export them
- * here and delete these definitions.
- *
- * Two transport lanes serialize into this SAME stored shape:
- * - harness lane: canonical `message.part.updated` parts, merged/normalized by
- *   `/stream` (`mergePersistedPart`, `finalizeAssistantParts`);
- * - router/openai-compat lane: `text_delta`/`tool_call` stream events are
- *   mapped INTO canonical part events first (`/runtime`'s `toLoopEvents` +
- *   `/stream`'s `normalizeToolEvent`) and then persisted identically — the
- *   store never sees a router-specific shape.
- */
-
-/** Start/end wall-clock millis, as normalized by `/stream`'s `normalizeTime`. */
-interface ChatPartTime {
-    start?: number;
-    end?: number;
-}
-/** `id` is the harness's per-segment identity; absent on legacy/router parts,
- *  which collapse to a single logical text stream. Never invented client-side. */
-interface ChatTextPart {
-    type: 'text';
-    text: string;
-    id?: string;
-}
-interface ChatReasoningPart {
-    type: 'reasoning';
-    text: string;
-    id?: string;
-    time?: ChatPartTime;
-}
-/** Superset of the sidecar's status enum (`pending|running|completed|failed`)
- *  and agent-interface's `ToolState` statuses; `error` is the persisted
- *  terminal form `/stream`'s `normalizePersistedPart` settles on. */
-type ChatToolStatus = 'pending' | 'running' | 'completed' | 'error' | 'failed';
-interface ChatToolState {
-    status: ChatToolStatus;
-    input?: unknown;
-    output?: unknown;
-    error?: string;
-    title?: string;
-    metadata?: Record<string, unknown>;
-    time?: ChatPartTime;
-}
-interface ChatToolPart {
-    type: 'tool';
-    id: string;
-    tool: string;
-    callID?: string;
-    state: ChatToolState;
-}
-/** Union of the sidecar's legacy (path-based) and AI-SDK (url-based) file
- *  shapes; response-side every field besides `type` is optional. */
-interface ChatFilePart {
-    type: 'file';
-    id?: string;
-    filename?: string;
-    mediaType?: string;
-    url?: string;
-    path?: string;
-    content?: string;
-}
-interface ChatImagePart {
-    type: 'image';
-    filename?: string;
-    mediaType?: string;
-    url?: string;
-    path?: string;
-}
-interface ChatSubtaskPart {
-    type: 'subtask';
-    prompt: string;
-    description: string;
-    agent: string;
-    id?: string;
-}
-/** OpenCode step-boundary marker — no renderable text; preserved so mappers
- *  never coerce it into a "[object Object]" text part. */
-interface ChatStepStartPart {
-    type: 'step-start';
-}
-/** Per-step usage receipt as the harness reports it (sidecar
- *  `StepFinishPartSchema`). The message-level token/cost columns are this
- *  shape flattened. */
-interface ChatUsageTokens {
-    total?: number;
-    input?: number;
-    output?: number;
-    reasoning?: number;
-    cache?: {
-        write?: number;
-        read?: number;
-    };
-}
-interface ChatStepFinishPart {
-    type: 'step-finish';
-    reason?: string;
-    tokens?: ChatUsageTokens;
-    cost?: number;
-}
-/** Persisted human-in-the-loop ask — byte-matches
- *  `interactionToPersistedPart` in `/web-react`'s chat-interactions contract. */
-interface ChatInteractionPart {
-    type: 'interaction';
-    id: string;
-    kind: string;
-    title: string;
-    body?: string;
-    answerSpec: {
-        fields: ChatInteractionField[];
-    };
-    status: ChatInteractionStatus;
-    answers?: InteractionAnswers;
-    cancelReason?: string;
-}
-type ChatPlanPart = ChatPlanPersistedPart;
-/** Persisted one-line transcript notice — byte-matches `noticePart` in
- *  `/web-react`'s chat-interactions contract. */
-interface ChatNoticePart {
-    type: 'notice';
-    id: string;
-    noticeKind: NoticeKind;
-    text: string;
-}
-type ChatMessagePart = ChatTextPart | ChatReasoningPart | ChatToolPart | ChatFilePart | ChatImagePart | ChatSubtaskPart | ChatStepStartPart | ChatStepFinishPart | ChatInteractionPart | ChatNoticePart | ChatPlanPart;
-/** Every canonical harness wire-part kind must be storable — compile-time
- *  guarantee that a new agent-interface part kind cannot silently fall out of
- *  the persisted vocabulary. */
-type StorableHarnessPartKind = Part['type'] & ChatMessagePart['type'];
-/**
- * The typed projection at the `/stream` → `/chat-store` boundary. The stream
- * normalizers (`normalizePersistedPart`/`mergePersistedPart`/
- * `finalizeAssistantParts`) deliberately produce untyped `JsonRecord`s — they
- * normalize wire shapes and do not own the stored vocabulary. THIS module
- * owns it, so this is where rows gain the `ChatMessagePart` type: each entry
- * is validated against its kind's required fields and narrowed, junk is
- * dropped, and — enforced by the exhaustiveness check below — no storable
- * kind can silently fall out (the step-finish/interaction trap).
- */
-declare function toChatMessageParts(parts: Array<Record<string, unknown>>): ChatMessagePart[];
-declare function isChatToolPart(part: ChatMessagePart): part is ChatToolPart;
-declare function isChatTextPart(part: ChatMessagePart): part is ChatTextPart;
-declare function isChatInteractionPart(part: ChatMessagePart): part is ChatInteractionPart;
-declare function isChatPlanPart(part: ChatMessagePart): part is ChatPlanPart;
-declare function isChatStepFinishPart(part: ChatMessagePart): part is ChatStepFinishPart;
-
-export { type ChatFilePart as C, type StorableHarnessPartKind as S, type ChatImagePart as a, type ChatInteractionPart as b, type ChatMessagePart as c, type ChatNoticePart as d, type ChatPartTime as e, type ChatPlanPart as f, type ChatReasoningPart as g, type ChatStepFinishPart as h, type ChatStepStartPart as i, type ChatSubtaskPart as j, type ChatTextPart as k, type ChatToolPart as l, type ChatToolState as m, type ChatToolStatus as n, type ChatUsageTokens as o, isChatInteractionPart as p, isChatPlanPart as q, isChatStepFinishPart as r, isChatTextPart as s, isChatToolPart as t, toChatMessageParts as u };