@illuma-ai/agents 1.4.0-alpha.6 → 1.5.0

package/dist/types/tools/artifacts/index.d.ts

@@ -1,3 +0,0 @@
-export { createArtifactTool, createContentReaderTool, ARTIFACT_TOOL_NAME, CONTENT_READER_NAME, ARTIFACT_WRITE_ACTIONS, CONTENT_READ_ACTIONS, } from './tool';
-export { artifactToolSchema, contentReaderSchema, type ArtifactToolInput, type ContentReaderInput, } from './schema';
-export type { ArtifactToolScope, ArtifactToolResult, ArtifactToolLogger, ArtifactToolBaseConfig, ArtifactToolConfig, ContentReaderToolConfig, ArtifactWriteHandlers, ContentReadHandlers, ContentIdResolver, WriteArgs, EditArgs, VerifyArgs, DeleteArgs, ReadArgs, SearchArgs, ListArgs, InfoArgs, } from './types';

package/dist/types/tools/artifacts/schema.d.ts

@@ -1,63 +0,0 @@
-import { z } from 'zod';
-export declare const ARTIFACT_WRITE_ACTIONS: readonly ["write", "edit", "verify", "delete"];
-export declare const CONTENT_READ_ACTIONS: readonly ["read", "search", "list", "info"];
-export declare const artifactToolSchema: z.ZodObject<{
-    action: z.ZodEnum<["write", "edit", "verify", "delete"]>;
-    content_id: z.ZodOptional<z.ZodString>;
-    content: z.ZodOptional<z.ZodString>;
-    name: z.ZodOptional<z.ZodString>;
-    old_str: z.ZodOptional<z.ZodString>;
-    new_str: z.ZodOptional<z.ZodString>;
-    replace_all: z.ZodOptional<z.ZodBoolean>;
-}, "strip", z.ZodTypeAny, {
-    action: "write" | "delete" | "edit" | "verify";
-    content?: string | undefined;
-    name?: string | undefined;
-    old_str?: string | undefined;
-    new_str?: string | undefined;
-    content_id?: string | undefined;
-    replace_all?: boolean | undefined;
-}, {
-    action: "write" | "delete" | "edit" | "verify";
-    content?: string | undefined;
-    name?: string | undefined;
-    old_str?: string | undefined;
-    new_str?: string | undefined;
-    content_id?: string | undefined;
-    replace_all?: boolean | undefined;
-}>;
-export declare const contentReaderSchema: z.ZodObject<{
-    action: z.ZodEnum<["read", "search", "list", "info"]>;
-    content_id: z.ZodOptional<z.ZodString>;
-    start_line: z.ZodOptional<z.ZodNumber>;
-    end_line: z.ZodOptional<z.ZodNumber>;
-    pattern: z.ZodOptional<z.ZodString>;
-    flags: z.ZodOptional<z.ZodString>;
-    context: z.ZodOptional<z.ZodNumber>;
-    offset: z.ZodOptional<z.ZodNumber>;
-    limit: z.ZodOptional<z.ZodNumber>;
-}, "strip", z.ZodTypeAny, {
-    action: "read" | "search" | "info" | "list";
-    pattern?: string | undefined;
-    context?: number | undefined;
-    flags?: string | undefined;
-    content_id?: string | undefined;
-    start_line?: number | undefined;
-    end_line?: number | undefined;
-    offset?: number | undefined;
-    limit?: number | undefined;
-}, {
-    action: "read" | "search" | "info" | "list";
-    pattern?: string | undefined;
-    context?: number | undefined;
-    flags?: string | undefined;
-    content_id?: string | undefined;
-    start_line?: number | undefined;
-    end_line?: number | undefined;
-    offset?: number | undefined;
-    limit?: number | undefined;
-}>;
-export declare const ARTIFACT_TOOL_NAME = "artifact_tool";
-export declare const CONTENT_READER_NAME = "content_reader";
-export type ArtifactToolInput = z.infer<typeof artifactToolSchema>;
-export type ContentReaderInput = z.infer<typeof contentReaderSchema>;

package/dist/types/tools/artifacts/tool.d.ts

@@ -1,16 +0,0 @@
-/**
- * artifact_tool + content_reader library factories.
- *
- * The library owns the LangChain wiring (schema, description, response
- * shape) and the action dispatch; the runtime supplies a handler bundle
- * matching the `ArtifactWriteHandlers` / `ContentReadHandlers` interface.
- *
- * This keeps 800+ LOC of host-specific handler logic (S3 adapters, file
- * model CRUD, syntax checkers, line utils) out of the library while
- * still centralizing the tool surface every runtime shares.
- */
-import { DynamicStructuredTool } from '@langchain/core/tools';
-import type { ArtifactToolConfig, ContentReaderToolConfig } from './types';
-export declare function createArtifactTool(config: ArtifactToolConfig): DynamicStructuredTool;
-export declare function createContentReaderTool(config: ContentReaderToolConfig): DynamicStructuredTool;
-export { ARTIFACT_TOOL_NAME, CONTENT_READER_NAME, ARTIFACT_WRITE_ACTIONS, CONTENT_READ_ACTIONS, } from './schema';

package/dist/types/tools/artifacts/types.d.ts

@@ -1,127 +0,0 @@
-/**
- * Artifact-tool types. The library owns the LangChain wiring, schema, and
- * action dispatch. Runtime supplies an `ArtifactHandlers` bundle — one
- * function per action — so ranger reuses its existing handlers, CLI
- * supplies disk-backed ones, and A2A server supplies buffer-backed ones.
- *
- * Each handler receives:
- *   - `args`: the parsed input (typed per action)
- *   - `scope`: runtime-resolved scope identity (conversationId + userId
- *     for ranger, agent-run-id for CLI, a2a-task-id for A2A)
- *
- * Each handler returns a `[llmText, toolArtifact]` tuple matching
- * LangChain's `content_and_artifact` response format.
- */
-export interface ArtifactToolScope {
-    /**
-     * Primary scope — whatever the runtime uses to silo artifacts per
-     * session/run/conversation. Ranger uses `conversationId`; CLI uses
-     * `agent-run-id` or `agent-id`; A2A uses `a2a-task-id`.
-     */
-    conversationId: string;
-    /** Optional — present when the runtime has an authenticated user. */
-    userId?: string;
-    /** Free-form extension — runtimes can add their own fields. */
-    [key: string]: unknown;
-}
-export type ArtifactToolResult = [llmText: string, artifact?: unknown];
-export interface WriteArgs {
-    action: 'write';
-    content_id?: string;
-    content: string;
-    name?: string;
-}
-export interface EditArgs {
-    action: 'edit';
-    content_id: string;
-    old_str: string;
-    new_str: string;
-    replace_all?: boolean;
-}
-export interface VerifyArgs {
-    action: 'verify';
-    content_id: string;
-}
-export interface DeleteArgs {
-    action: 'delete';
-    content_id: string;
-}
-export interface ReadArgs {
-    action: 'read';
-    content_id: string;
-    start_line?: number;
-    end_line?: number;
-    offset?: number;
-    limit?: number;
-}
-export interface SearchArgs {
-    action: 'search';
-    content_id: string;
-    pattern: string;
-    flags?: string;
-    context?: number;
-    offset?: number;
-    limit?: number;
-}
-export interface ListArgs {
-    action: 'list';
-}
-export interface InfoArgs {
-    action: 'info';
-    content_id: string;
-}
-export type ArtifactWriteAction = WriteArgs | EditArgs | VerifyArgs | DeleteArgs;
-export type ArtifactReadAction = ReadArgs | SearchArgs | ListArgs | InfoArgs;
-/** Writer-surface handlers — invoked by `artifact_tool`. */
-export interface ArtifactWriteHandlers {
-    write(args: WriteArgs, scope: ArtifactToolScope): Promise<ArtifactToolResult>;
-    edit(args: EditArgs, scope: ArtifactToolScope): Promise<ArtifactToolResult>;
-    verify(args: VerifyArgs, scope: ArtifactToolScope): Promise<ArtifactToolResult>;
-    delete(args: DeleteArgs, scope: ArtifactToolScope): Promise<ArtifactToolResult>;
-}
-/** Reader-surface handlers — invoked by `content_reader`. */
-export interface ContentReadHandlers {
-    read(args: ReadArgs, scope: ArtifactToolScope): Promise<ArtifactToolResult>;
-    search(args: SearchArgs, scope: ArtifactToolScope): Promise<ArtifactToolResult>;
-    list(args: ListArgs, scope: ArtifactToolScope): Promise<ArtifactToolResult>;
-    info(args: InfoArgs, scope: ArtifactToolScope): Promise<ArtifactToolResult>;
-}
-/**
- * Optional content_id self-healing: runtimes that want to let the LLM
- * pass nicknames (e.g., "Dashboard") instead of canonical IDs implement
- * this. Library falls through when unset.
- */
-export interface ContentIdResolver {
-    resolve(id: string, scope: ArtifactToolScope): Promise<{
-        resolvedId: string;
-        resolvedName?: string;
-    } | null>;
-}
-export interface ArtifactToolLogger {
-    debug: (msg: string, ...args: unknown[]) => void;
-    info: (msg: string, ...args: unknown[]) => void;
-    warn: (msg: string, ...args: unknown[]) => void;
-    error: (msg: string, ...args: unknown[]) => void;
-}
-export interface ArtifactToolBaseConfig {
-    /**
-     * Resolves the runtime scope from the LangChain `config` object on each
-     * invocation. Ranger pulls `conversationId` + `userId` from request
-     * metadata; CLI pulls `agent-run-id` from its runner context.
-     */
-    getScope: (config: unknown) => ArtifactToolScope | null;
-    resolver?: ContentIdResolver;
-    logger?: ArtifactToolLogger;
-    /**
-     * Description override. Host can inject brand-specific guidance
-     * (e.g., ranger's HTML branding mandate, TSX style rules). Defaults
-     * to a generic description appropriate for any runtime.
-     */
-    descriptionOverride?: string;
-}
-export interface ArtifactToolConfig extends ArtifactToolBaseConfig {
-    handlers: ArtifactWriteHandlers;
-}
-export interface ContentReaderToolConfig extends ArtifactToolBaseConfig {
-    handlers: ContentReadHandlers;
-}

package/dist/types/tools/fileSearch/formatter.d.ts

@@ -1,25 +0,0 @@
-/**
- * Default result formatters.
- *
- * - `plainTextFormatter`: CLI / A2A / generic output. No citation anchors.
- * - `citationAnchorFormatter`: ranger-style `\ue202turn0fileN` anchors with
- *   a monotonic `sourceOffset` so multi-call turns stay globally unique.
- *
- * Runtimes can supply their own `FileSearchResultFormatter` to override.
- */
-import type { FileSearchResultFormatter, FileSearchFile, RagChunk } from './types';
-export declare const plainTextFormatter: FileSearchResultFormatter;
-export interface CitationAnchorFormatterOptions {
-    /** Tool name used in the `file_search` artifact wrapper. Defaults to `'file_search'`. */
-    toolName?: string;
-    /**
-     * Monotonic counter for source indices within a turn. Pass the SAME
-     * function to the formatter across multiple calls in the same turn so
-     * anchors stay globally unique.
-     */
-    getSourceOffset?: () => number;
-    /** Called after formatting to advance the offset. */
-    advanceSourceOffset?: (by: number) => void;
-}
-export declare function createCitationAnchorFormatter(opts?: CitationAnchorFormatterOptions): FileSearchResultFormatter;
-export type { FileSearchResultFormatter, FileSearchFile, RagChunk };

package/dist/types/tools/fileSearch/index.d.ts

@@ -1,5 +0,0 @@
-export { createFileSearchTool, FileSearchToolName } from './tool';
-export { HttpRagClient, getRagBaseUrl, RAG_API_URL_ENV, type HttpRagClientOptions, } from './ragClient';
-export { plainTextFormatter, createCitationAnchorFormatter, type CitationAnchorFormatterOptions, } from './formatter';
-export { fileSearchInputSchema, type FileSearchInput } from './schema';
-export type { FileSearchFile, RagChunk, RagClient, RagQueryParams, FileSearchResultFormatter, FileSearchToolCallbacks, FileSearchToolConfig, FileSearchToolLogger, } from './types';

package/dist/types/tools/fileSearch/ragClient.d.ts

@@ -1,32 +0,0 @@
-/**
- * Default HTTP RAG client. Posts to `${baseUrl}/query` with the shape
- * rag_api expects (`{ file_id, query, k, entity_id? }`). Runtimes that
- * use a different vector backend implement their own `RagClient`.
- *
- * Auth is runtime-provided per call (via `authHeaders` on the params) so
- * short-lived tokens can be minted per request without the client
- * caching stale credentials.
- */
-import type { RagClient, RagQueryParams, RagChunk, FileSearchToolLogger } from './types';
-export declare const RAG_API_URL_ENV = "RAG_API_URL";
-/** Resolve base URL at call time so env-var changes propagate. */
-export declare function getRagBaseUrl(override?: string): string;
-export interface HttpRagClientOptions {
-    /** Base URL of the RAG service (no trailing slash). Falls back to env. */
-    baseUrl?: string;
-    /** Default headers sent on every request (e.g., a static API key). */
-    defaultHeaders?: Record<string, string>;
-    /** Default timeout if params don't override. Default 15_000. */
-    defaultTimeoutMs?: number;
-    logger?: FileSearchToolLogger;
-}
-export declare class HttpRagClient implements RagClient {
-    private readonly baseUrlOverride?;
-    private readonly defaultHeaders;
-    private readonly defaultTimeoutMs;
-    private readonly logger?;
-    constructor(opts?: HttpRagClientOptions);
-    query(params: RagQueryParams): Promise<RagChunk[]>;
-    /** Convert rag_api's tuple format into the library's normalized shape. */
-    private normalize;
-}

package/dist/types/tools/fileSearch/schema.d.ts

@@ -1,13 +0,0 @@
-import { z } from 'zod';
-export declare const fileSearchInputSchema: z.ZodObject<{
-    query: z.ZodString;
-    target_files: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-}, "strip", z.ZodTypeAny, {
-    query: string;
-    target_files?: string[] | undefined;
-}, {
-    query: string;
-    target_files?: string[] | undefined;
-}>;
-export type FileSearchInput = z.infer<typeof fileSearchInputSchema>;
-export declare const FileSearchToolName = "file_search";

package/dist/types/tools/fileSearch/tool.d.ts

@@ -1,18 +0,0 @@
-/**
- * file_search tool factory — library-native equivalent of the CodeExecutor
- * pattern. Runtimes supply a `RagClient`, the file list for this turn, and
- * an optional formatter (ranger uses citation anchors; CLI/A2A use plain
- * text).
- *
- * The tool itself:
- *   1. Accepts `{ query, target_files? }` from the LLM.
- *   2. Filters files by `target_files` substring match when provided.
- *   3. Queries each file in bounded concurrent batches.
- *   4. Enforces per-file timeouts (failures isolated per file).
- *   5. Flattens chunks, deprioritizes stale-turn files, caps results.
- *   6. Hands formatted output to the runtime's formatter for final shape.
- */
-import { DynamicStructuredTool } from '@langchain/core/tools';
-import type { FileSearchToolConfig } from './types';
-export declare function createFileSearchTool(config: FileSearchToolConfig): DynamicStructuredTool;
-export { FileSearchToolName } from './schema';

package/dist/types/tools/fileSearch/types.d.ts

@@ -1,139 +0,0 @@
-/**
- * File-search tool types. Mirrors the web_search / code_executor split —
- * the library owns tool logic; the host supplies a `RagClient` + config
- * shaped to its own deployment (auth strategy, scope identity, file set).
- */
-export interface FileSearchFile {
-    /** Stable identifier within the RAG backend. */
-    file_id: string;
-    /** Human-readable name surfaced in tool results and prompts. */
-    filename: string;
-    /**
-     * Hint that this file arrived on the *current* conversation turn (as
-     * opposed to an earlier turn). Hosts that don't distinguish leave this
-     * undefined; the formatter deprioritizes older files when set.
-     */
-    isCurrentMessage?: boolean;
-}
-/**
- * A single chunk returned by the RAG backend for a query.
- * Shape is normalized here so the library stays independent of any
- * specific RAG service's response format — the `RagClient` is responsible
- * for translating the backend response into this shape.
- */
-export interface RagChunk {
-    file_id: string;
-    page_content: string;
-    distance: number;
-    metadata?: Record<string, unknown>;
-}
-export interface RagQueryParams {
-    file_id: string;
-    query: string;
-    /** Top-K chunks to return per file. Default 10. */
-    k?: number;
-    /** Optional tenant/entity ID — forwarded to the backend verbatim. */
-    entity_id?: string;
-    /**
-     * Scope identifier. Hosts use this for per-tenant isolation in the RAG
-     * backend (ranger → userId, cli → agentId, a2a → task-id).
-     */
-    scope?: string;
-    /**
-     * Per-request auth headers — the host builds these (e.g., ranger sends
-     * `Authorization: Bearer <short-lived-JWT-for-userId>`). Allows
-     * different runtimes to use different auth strategies without the
-     * library knowing.
-     */
-    authHeaders?: Record<string, string>;
-    /** Optional per-call timeout override. */
-    timeoutMs?: number;
-}
-/**
- * Pluggable RAG backend. Runtimes provide an implementation that speaks
- * to whatever vector DB / search service they've deployed (rag_api is the
- * default; azure search, pinecone, etc. are valid alternates).
- */
-export interface RagClient {
-    query(params: RagQueryParams): Promise<RagChunk[]>;
-}
-/**
- * Formatter callback that shapes raw chunks into the runtime's preferred
- * presentation. Ranger uses citation anchors (`\ue202turn0fileN`), CLI
- * uses plain text, A2A server can return structured parts.
- */
-export interface FileSearchResultFormatter {
-    format(chunks: Array<RagChunk & {
-        filename: string;
-        isCurrentMessage: boolean;
-    }>, context: {
-        /**
-         * Monotonic call index within a single turn. Ranger uses this to
-         * keep citation source indices globally unique across multiple
-         * file_search invocations.
-         */
-        callIndex: number;
-        /** Same files list the factory was seeded with (for lookups). */
-        files: FileSearchFile[];
-    }): {
-        /** Message returned to the LLM (content). */
-        message: string;
-        /** Optional artifact payload (sources, metadata) returned alongside. */
-        artifact?: unknown;
-    };
-}
-export interface FileSearchToolCallbacks {
-    /**
-     * Fires when a RAG query completes successfully for one file. Hosts can
-     * use this for telemetry, streaming UI updates, etc.
-     */
-    onFileQueried?: (file: FileSearchFile, chunkCount: number) => void;
-    /** Fires when a RAG query fails. Hosts can log or surface via UI. */
-    onFileError?: (file: FileSearchFile, error: Error) => void;
-}
-export interface FileSearchToolLogger {
-    debug: (msg: string, ...args: unknown[]) => void;
-    info: (msg: string, ...args: unknown[]) => void;
-    warn: (msg: string, ...args: unknown[]) => void;
-    error: (msg: string, ...args: unknown[]) => void;
-}
-export interface FileSearchToolConfig {
-    /** The RAG backend client. Required. */
-    ragClient: RagClient;
-    /** Files the agent has access to this turn. Empty = tool self-reports so. */
-    files: FileSearchFile[];
-    /** Tenant/entity ID forwarded to the backend per-query. */
-    entity_id?: string;
-    /**
-     * Per-turn scope identity. Most runtimes pin this once (userId/agentId);
-     * if omitted, no scope is sent to the backend.
-     */
-    scope?: string;
-    /**
-     * Per-call auth header builder. Called on every tool invocation so
-     * the host can mint fresh short-lived tokens (ranger's JWT pattern).
-     * When omitted, no auth headers are sent.
-     */
-    getAuthHeaders?: () => Record<string, string> | Promise<Record<string, string>>;
-    /**
-     * Result formatter. When omitted, the default plain-text formatter is
-     * used (suitable for CLI/A2A runtimes that don't need citation anchors).
-     */
-    formatter?: FileSearchResultFormatter;
-    /** Per-file query timeout in ms. Default 15_000. */
-    queryTimeoutMs?: number;
-    /**
-     * Max concurrent in-flight RAG queries. Protects HTTP connection pools
-     * under heavy file counts. Default 10.
-     */
-    concurrencyLimit?: number;
-    /** Top-K chunks per file. Default 10. */
-    topK?: number;
-    /**
-     * Cap on total chunks returned to the LLM after sorting. Default is
-     * `max(10, filesCount * 3)`.
-     */
-    resultCap?: number;
-    callbacks?: FileSearchToolCallbacks;
-    logger?: FileSearchToolLogger;
-}

package/dist/types/tools/proxyTool.d.ts

@@ -1,62 +0,0 @@
-/**
- * proxyTool — wraps a Capability into a LangChain StructuredTool that
- * dispatches execution to a remote backend (e.g., tools-server) over HTTP.
- *
- * The LLM sees this tool identically to a locally-implemented tool:
- *   - same name
- *   - same description
- *   - same input schema (JSON Schema)
- *   - same invoke(input) contract
- *
- * Under the hood, invoke() POSTs to the backend's execute endpoint with
- * the input and a caller-supplied credential map. The backend returns
- * { success, result, error, timing } which this wrapper unpacks.
- */
-import type { AxiosInstance } from 'axios';
-import { type StructuredToolInterface } from '@langchain/core/tools';
-import type { Capability, CredentialMap } from '@/providers/types';
-/** Shape of the backend's execute response. Matches tools-server. */
-export interface ExecuteResponse {
-    success: boolean;
-    result?: unknown;
-    error?: string;
-    timing?: {
-        durationMs: number;
-    };
-}
-/** Options passed to buildProxyTool. */
-export interface ProxyToolOptions {
-    /** HTTP client configured with backend base URL + auth. */
-    client: AxiosInstance;
-    /**
-     * Path template for execution. The literal `:name` is replaced with the
-     * capability's name. Defaults to `/execute/:name` (tools-server convention).
-     */
-    executePath?: string;
-    /**
-     * Optional callback invoked on every execution — used for metrics,
-     * telemetry, debug logging. Errors in the hook are swallowed.
-     */
-    onExecute?: (ctx: ExecuteCallbackContext) => void;
-    /**
-     * Optional per-invocation auth header builder. Called on every tool
-     * invocation before POSTing; returned headers are merged into the
-     * request alongside the base client's headers. Typical use: pass a
-     * freshly minted per-user JWT for admin-gated tools.
-     */
-    getAuthHeaders?: () => Record<string, string> | Promise<Record<string, string>>;
-}
-export interface ExecuteCallbackContext {
-    capabilityName: string;
-    input: unknown;
-    response?: ExecuteResponse;
-    error?: Error;
-    durationMs: number;
-}
-/**
- * Build a StructuredTool that proxies to a remote backend.
- *
- * The credentialMap is baked into the closure — callers that need
- * per-invocation credential rotation should rebuild the tool.
- */
-export declare function buildProxyTool(capability: Capability, credentials: CredentialMap, options: ProxyToolOptions): StructuredToolInterface;

package/dist/types/utils/childAgentContext.d.ts

@@ -1,99 +0,0 @@
-/**
- * Child-agent context preparation utilities.
- *
- * When a parent agent invokes a child agent — via handoff, sequence edge,
- * or scoped subgraph — the child cannot just receive `state.messages`
- * verbatim. The parent's conversation contains tool_use/tool_result blocks
- * that are (a) often incompatible with the child's tool registry, and
- * (b) actively harmful to the child's ability to reason cleanly about its
- * own task (noise → schema confusion → malformed tool_use).
- *
- * This module provides the two canonical strategies, extracted from
- * `MultiAgentGraph` so they can be unit-tested in isolation and reused by
- * future sub-agent orchestrators:
- *
- *   1. `prepareHandoffMessages` — "cleaned parent history"
- *      Used when the child still needs the orchestrator's context (it's
- *      the handoff target). Drops orphaned tool_use, compacts paired
- *      tool_use/tool_result into text summaries, and guarantees the tail
- *      is a HumanMessage so Bedrock/VertexAI won't reject the conversation
- *      with "assistant message prefill" errors.
- *
- *   2. `prepareIsolatedChildMessages` — "fresh session"
- *      Used for downstream sequence-node children inside a scoped subgraph.
- *      The child sees only the original user request plus a synthetic
- *      HumanMessage summarizing the upstream agent's final text output and
- *      directing the child to act. Raw upstream tool_use/tool_result blocks
- *      are discarded.
- *
- * Both helpers are pure functions over message arrays — no I/O, no
- * LangGraph coupling — so they can be exercised by unit tests with
- * synthetic message fixtures.
- */
-import type { BaseMessage } from '@langchain/core/messages';
-/**
- * Prefix injected in front of a trailing AIMessage when we flip it to a
- * HumanMessage to satisfy provider "last message must be user" rules.
- */
-export declare const HANDOFF_TAIL_CONTEXT_PREFIX = "[Context from orchestrator]: ";
-/**
- * Directive task-framing wrapper for downstream scoped-subgraph children.
- *
- * Design notes — each line is load-bearing:
- *  - "Prior step output" names the upstream role without leaking the
- *    agent's internal id.
- *  - "You MUST now perform..." replaces ambiguity with obligation.
- *  - "system instructions" references the agent's stored system prompt
- *    as the source of task definition — so operators can tune behavior
- *    via data, not code.
- *  - The tool-first clause prevents small/fast models from stalling on a
- *    text-only acknowledgement when a tool action is expected.
- */
-export declare function buildIsolatedChildPrompt(upstreamText: string): string;
-/**
- * Prepare messages for a handoff child agent.
- *
- * Handles two problems that break Bedrock/Anthropic conversations:
- *
- * 1. **Orphaned tool_use**: The parent's AI message contains a `tool_use`
- *    block for the handoff tool itself, with no matching `tool_result`.
- *    Providers (Bedrock/Anthropic) reject this.
- *
- * 2. **Paired tool_use/tool_result in history**: The child may not have
- *    the same tools as the parent. Bedrock requires `toolConfig` when any
- *    tool_use/tool_result blocks exist in the history. Compacting these
- *    into text summaries avoids the requirement and reduces context bloat.
- *
- * Also ensures the tail is a HumanMessage — some providers reject a
- * conversation that ends with an assistant message.
- *
- * @param messages - Current state messages from the parent
- * @returns A sanitized copy, safe to pass to any provider as the child's
- *          input regardless of which tools the child has registered.
- */
-export declare function prepareHandoffMessages(messages: BaseMessage[]): BaseMessage[];
-/**
- * Build an ISOLATED message context for a downstream scoped-subgraph node.
- *
- * Unlike `prepareHandoffMessages` (which cleans up tool_use artifacts but
- * preserves most of the parent history), this helper produces a fresh
- * minimal context containing only:
- *
- *   1. The original user request (first HumanMessage in the history)
- *   2. A synthetic HumanMessage summarizing the upstream agent's final
- *      text output and directing the downstream agent to act on it
- *
- * Tool_use / tool_result blocks from the upstream agent are discarded —
- * the downstream agent shouldn't reason about how the upstream agent did
- * its work, only about the result.
- *
- * This "fresh subagent session" pattern is the primary defense against
- * schema confusion / malformed tool_use JSON that occurs when downstream
- * models see a noisy upstream conversation.
- *
- * Defensive fallback: if the messages array contains neither a user
- * message nor a non-empty upstream AI message, return the input unchanged
- * so the caller still has something to invoke on. This only matters for
- * malformed state fixtures in tests.
- */
-export declare function prepareIsolatedChildMessages(messages: BaseMessage[]): BaseMessage[];