memeloop 0.0.1 → 0.1.1

package/dist/promptConcat-D6wr5V-V.d.cts

@@ -0,0 +1,516 @@
+import { q as LoopProfileScriptReference, h as AgentLoopScriptPolicy, i as AgentLoopStep, f as AgentLoopInput, n as LoopProfile, g as AgentLoopRuntime, e as AgentLoopGenerator, B as AgentClient, C as ScriptDeploymentClient, d as AgentLoopDefinition, k as ILLMProvider, A as AgentFrameworkContext, L as LoopPlugin, o as LoopProfilePluginEntry, P as PromptConcatTool } from './scriptDeploymentPipeline-yG1ZhVVI.cjs';
+import { t as AgentOrchestrationClient, b as ChatMessage, W as PromptNode, X as AgentPromptDescription } from './interface-IrKBFtL1.cjs';
+import { c as AgentStopData, i as HookType, g as HookHandler, H as HookContext, h as HookResult } from './registry-D0kbxksn.cjs';
+
+declare const BUILTIN_AGENT_AGENT_LOOP_ARTIFACT_RESOURCE_LIFECYCLE_SCRIPT_ID = "builtin:agent-agent-loop/artifact-resource-lifecycle";
+declare const BUILTIN_AGENT_AGENT_LOOP_DECLARATIVE_AGENT_RUN_SCRIPT_ID = "builtin:agent-agent-loop/declarative-agent-run";
+declare const BUILTIN_AGENT_AGENT_LOOP_QUALITY_GATE_SCRIPT_ID = "builtin:agent-agent-loop/quality-gate";
+declare const builtinAgentAgentLoopSources: Readonly<Record<string, string>>;
+declare function getBuiltinAgentAgentLoopSource(id: string): string | undefined;
+
+/**
+ * Agent loop script loader (plan 24.15: source is never imported directly
+ * from an LLM string without passing the admission chain).
+ *
+ * Loading rules:
+ * - Builtin loop sources are allowlisted by content digest at startup
+ *   ({@link registerBuiltinScriptSources}); they load with zero gate overhead.
+ * - Any other source-bearing reference (`source` refs and `data:` URLs) must
+ *   pass the host-injected {@link ScriptLoadGate}: validate (AST) → admit
+ *   (trust-class policy) → only then `import()`.
+ * - When no gate is configured, all non-builtin sources are DENIED
+ *   (fail-closed) with a structured {@link ScriptLoadDeniedError}.
+ *
+ * Admission results (trust class, RuntimeClass, checkpoint compatibility)
+ * are attached to the loaded script via {@link LOADED_SCRIPT_METADATA} so
+ * hosts can enforce sandboxing.
+ */
+
+type AgentLoopScriptReference = string | LoopProfileScriptReference;
+
+type LoadAgentAgentLoopScriptOptions = AgentLoopScriptPolicy;
+type AgentAgentLoopScriptReference = AgentLoopScriptReference;
+declare function loadAgentAgentLoopScript(scriptReference: AgentAgentLoopScriptReference, options?: LoadAgentAgentLoopScriptOptions): Promise<AgentAgentLoopScript>;
+
+/**
+ * AgentAgent_Loop — a loop that orchestrates child agents.
+ *
+ * This loop does NOT call the LLM directly. Instead it coordinates child agents:
+ * - running a child agent and feeding its result to another child agent (review / verify)
+ * - splitting work across multiple parallel child agents
+ * - looping back to a child agent with feedback when a reviewer rejects the output
+ *
+ * The loop script (.mjs) holds the orchestration logic. This file provides the
+ * runtime that invokes the script and manages child agent runs.
+ */
+
+/**
+ * Typed API passed to a AgentAgent `.mjs` script.
+ *
+ * The API is intentionally primitive: scripts decide the workflow shape, role
+ * names, approval rules, retry limits, and delivery gates. This runtime only
+ * handles child-agent execution, progress events, cancellation, state, and
+ * checkpoints.
+ */
+interface AgentAgentLoopScriptArguments {
+    /** The parent turn input. `input.message` is the user's original goal. */
+    input: AgentLoopInput;
+    /** Host/runtime context for advanced integrations. Prefer the typed helpers below when possible. */
+    context: AgentAgentLoopContext;
+    /** Active profile. Scripts may define their own workflow-specific metadata keys here. */
+    profile?: LoopProfile;
+    /** Normalized worker agents read from `context.agents` or `profile.metadata.agents`. */
+    agents: AgentAgentDescriptor[];
+    /**
+     * Read raw agent entries from `profile.metadata[key]`; defaults to `agents`.
+     * This is deliberately generic so scripts can choose names like `critics`,
+     * `builders`, `verifiers`, or any other workflow-specific role.
+     */
+    getAgentEntries: (key?: string) => AgentAgentConfigEntry[];
+    /** Low-level runtime hooks. Prefer `state`, `checkpoint`, `emit`, and run helpers first. */
+    runtime?: Partial<AgentLoopRuntime>;
+    /** Policy-scoped declarative manager facade. It never exposes raw infrastructure drivers or secrets. */
+    orchestration?: AgentOrchestrationClient;
+    /** Typed convenience client for creating, reading, and deleting Agent workloads and runs. */
+    agentClient?: AgentClient;
+    /**
+     * Declarative generated-script deployment (plan 24.14). The script declares
+     * placement and lifecycle; trust, interface ceilings, and persistence are
+     * host-bound. Undefined when the host provides no deployment configuration.
+     */
+    scriptClient?: ScriptDeploymentClient;
+    /** Run one child agent and collect all yielded steps into a text result. */
+    runAgent: (input: AgentAgentRunAgentInput) => Promise<AgentAgentRunAgentResult>;
+    /** Run child agents concurrently. Use `runSequential` when order matters. */
+    runAgents: (inputs: AgentAgentRunAgentInput[]) => Promise<AgentAgentRunAgentResult[]>;
+    /** Run a batch of agents in order, aggregating successful output and failures. */
+    runSequential: (input?: AgentAgentBatchRunInput) => Promise<AgentAgentBatchRunResult>;
+    /** Run a batch of agents concurrently, aggregating successful output and failures. */
+    runParallel: (input?: AgentAgentBatchRunInput) => Promise<AgentAgentBatchRunResult>;
+    /** Format a batch result for final delivery or an intermediate report. */
+    formatAgentResults: (result: AgentAgentBatchRunResult, options?: AgentAgentFormatResultsOptions) => string;
+    /** Emit a formatted batch result as the parent loop's final/user-visible message. */
+    finishAgentResults: (result: AgentAgentBatchRunResult, options?: AgentAgentFormatResultsOptions) => void;
+    /** Emit a raw loop step upstream. Use sparingly; helpers already emit progress. */
+    emit: (step: AgentLoopStep) => void;
+    /** Emit a user-visible message or step and end the script's work. */
+    finish: (message: string | AgentLoopStep) => void;
+    /** True when the host cancelled this parent run. Long-running scripts should check this between phases. */
+    isCancelled: () => boolean;
+    /** Write an observability event through the host runtime logger. */
+    log: (event: string, data?: Record<string, unknown>) => void;
+    /** Per-run persistent state scoped by the host runtime. */
+    state: AgentLoopRuntime['state'];
+    /** Record a resumable milestone for long workflows. */
+    checkpoint: AgentLoopRuntime['checkpoint'];
+    /** Read a milestone recorded by an earlier process and skip completed work. */
+    loadCheckpoint: AgentLoopRuntime['loadCheckpoint'];
+}
+type AgentAgentScriptContext = AgentAgentLoopScriptArguments;
+type AgentAgentContext = AgentAgentScriptContext;
+interface AgentAgentDescriptor {
+    /** Child profile id to run. */
+    profileId: string;
+    /** Prompt override for this child run. Defaults to the parent input message. */
+    prompt?: string;
+    /** Conversation id override. Defaults to `${parent}:child:${index}` for batch helpers. */
+    conversationId?: string;
+    /** Optional human-readable role label, e.g. "implementer" or "reviewer". */
+    label?: string;
+    [key: string]: unknown;
+}
+type AgentAgentConfigEntry = string | ({
+    profileId?: string;
+    profile?: string;
+    prompt?: string;
+    conversationId?: string;
+    label?: string;
+} & Record<string, unknown>);
+interface AgentAgentRunAgentInput {
+    /** Child profile id. `profile` is accepted as an ergonomic alias for scripts. */
+    profileId?: string;
+    profile?: string;
+    /** Defaults to the parent input message. */
+    prompt?: string;
+    conversationId?: string;
+    label?: string;
+}
+interface AgentAgentRunAgentResult {
+    profileId: string;
+    conversationId: string;
+    steps: AgentLoopStep[];
+    text: string;
+}
+interface AgentAgentRunAgentFailure {
+    profileId: string;
+    conversationId?: string;
+    error: string;
+}
+interface AgentAgentBatchRunInput {
+    /** Agents to run. Defaults to `ctx.agents`. */
+    agents?: AgentAgentConfigEntry[];
+    /** Prompt shared by every agent in this batch. Defaults to the parent input message. */
+    prompt?: string;
+    /** When false, the first child failure rejects the batch. Defaults to true. */
+    continueOnError?: boolean;
+}
+interface AgentAgentBatchRunResult {
+    results: AgentAgentRunAgentResult[];
+    failures: AgentAgentRunAgentFailure[];
+    text: string;
+}
+interface AgentAgentFormatResultsOptions {
+    emptyMessage?: string;
+    failureHeader?: string;
+    includeFailureSection?: boolean;
+}
+type AgentAgentLoopScriptResult = AgentLoopGenerator | AgentLoopStep | AgentLoopStep[] | string | undefined;
+type AgentAgentLoopScript = (scriptArguments: AgentAgentLoopScriptArguments) => AgentAgentLoopScriptResult | Promise<AgentAgentLoopScriptResult>;
+interface AgentAgentLoopContext {
+    [key: string]: unknown;
+    profile?: LoopProfile;
+    runtime?: Partial<AgentLoopRuntime>;
+    agents?: AgentAgentConfigEntry[];
+    script?: AgentAgentLoopScript;
+    loadScript?: (script: AgentAgentLoopScriptReference, context: AgentAgentLoopContext) => AgentAgentLoopScript | Promise<AgentAgentLoopScript>;
+    scriptPolicy?: LoadAgentAgentLoopScriptOptions;
+}
+/**
+ * Create the AgentAgent_Loop definition and register it with the loop registry.
+ */
+declare function createAgentAgentLoopDefinition(): AgentLoopDefinition;
+/** Export loop id for consumers. */
+declare function getAgentAgentLoopId(): string;
+
+declare const BUILTIN_AGENT_TOOL_LOOP_DEFAULT_SCRIPT_ID = "builtin:agent-tool-loop/default";
+declare const builtinAgentToolLoopSources: Readonly<Record<string, string>>;
+declare function getBuiltinAgentToolLoopSource(id: string): string | undefined;
+
+interface CompactionOptions {
+    /** Maximum token count to aim for after compaction (estimated by char count / 3.5). Default: 0 (no limit). */
+    maxTokens?: number;
+    /** Number of recent message turns (user+assistant pairs) to preserve. Default: 4. */
+    recentTurnsToKeep?: number;
+    /** Whether to attempt LLM summarization. Falls back to truncation if LLM unavailable or fails. Default: true. */
+    useLlmSummary?: boolean;
+    /** Optional LLM provider for summarization. */
+    llmProvider?: ILLMProvider;
+}
+interface CompactionResult {
+    /** Compacted messages (summary + recent turns). */
+    messages: ChatMessage[];
+    /** True if compaction reduced the message count. */
+    compacted: boolean;
+    /** Number of messages dropped. */
+    droppedCount: number;
+    /** Summary text generated or fallback notice. */
+    summaryText: string;
+}
+/**
+ * Deterministic compaction: keeps recent N turns and replaces older messages
+ * with a single summary message.
+ */
+declare function compactMessages(messages: ChatMessage[], options?: Omit<CompactionOptions, 'llmProvider' | 'useLlmSummary'>): CompactionResult;
+/**
+ * Checks whether compaction is needed based on message count threshold.
+ * @returns true if message count exceeds threshold (default 50).
+ */
+declare function shouldCompact(messages: ChatMessage[], threshold?: number): boolean;
+/**
+ * Auto-compact: estimates token usage, and if it exceeds maxTokens,
+ * performs compaction to keep the context within bounds.
+ *
+ * Uses the LLM provider for summarization if available, falling back to
+ * simple truncation + turn counting.
+ */
+declare function autoCompact(messages: ChatMessage[], options?: CompactionOptions): Promise<CompactionResult>;
+
+type LoadAgentToolLoopScriptOptions$1 = AgentLoopScriptPolicy;
+type AgentToolLoopScriptReference$1 = AgentLoopScriptReference;
+interface AgentToolLoopContext extends AgentFrameworkContext {
+    profile?: LoopProfile;
+    runtime?: Partial<AgentLoopRuntime>;
+    script?: AgentToolLoopScript;
+    loadScript?: (script: AgentToolLoopScriptReference$1, context: AgentToolLoopContext) => AgentToolLoopScript | Promise<AgentToolLoopScript>;
+    scriptPolicy?: LoadAgentToolLoopScriptOptions$1;
+}
+interface AgentToolLoopState {
+    iteration: number;
+    maxIterations: number;
+    recentToolCalls: string[];
+    agentStarted: boolean;
+    agentStopped: boolean;
+    stopReason?: AgentStopData['reason'];
+}
+interface AgentToolLoopTurnStartResult {
+    action: 'continue' | 'stop';
+    step?: AgentLoopStep;
+}
+interface AgentToolLoopIterationResult {
+    action: 'continue' | 'stop';
+    reason?: AgentStopData['reason'];
+}
+type AgentToolLoopIterationGenerator = AsyncGenerator<AgentLoopStep, AgentToolLoopIterationResult, void>;
+interface AgentToolLoopScriptContext {
+    /** The host turn input. `input.message` is the user prompt for this turn. */
+    input: AgentLoopInput;
+    /** Full host context for advanced integrations. Prefer the primitive helpers below. */
+    context: AgentToolLoopContext;
+    /** Active profile selected by the registry/runtime. */
+    profile?: LoopProfile;
+    /** Create mutable loop state for one turn. Scripts can store it in checkpoints if they implement resume. */
+    createState: () => AgentToolLoopState;
+    /** Persist the user turn and run pre-agent hooks. Returns a blocking step when a hook stops the turn. */
+    startTurn: (state: AgentToolLoopState) => Promise<AgentToolLoopTurnStartResult>;
+    /** Run exactly one LLM/tool iteration. The script owns the surrounding loop policy. */
+    runIteration: (state: AgentToolLoopState) => AgentToolLoopIterationGenerator;
+    /** Run AgentStop hooks once. Pass a reason when stopping because of an error outside `runIteration`. */
+    stopTurn: (state: AgentToolLoopState, reason?: AgentStopData['reason']) => Promise<void>;
+    /** Emit a raw loop step upstream. */
+    emit: (step: AgentLoopStep) => void;
+    /** Emit a user-visible message or step. */
+    finish: (message: string | AgentLoopStep) => void;
+    /** True when host cancellation has been requested for this conversation. */
+    isCancelled: () => boolean;
+    /** Write an observability event through the runtime and host logger. */
+    log: (event: string, data?: Record<string, unknown>) => void;
+}
+type AgentToolLoopScriptResult = AgentLoopGenerator | AgentLoopStep | AgentLoopStep[] | string | undefined;
+type AgentToolLoopScript = (scriptContext: AgentToolLoopScriptContext) => AgentToolLoopScriptResult | Promise<AgentToolLoopScriptResult>;
+
+/**
+ * Direct agent/tool runner with no dynamic script-loader dependency.
+ *
+ * This is the portable path used by React Native. Hosts that need deployable
+ * script references use `createAgentToolLoopDefinition` from the full entry.
+ */
+declare function createAgentToolLoopRunner(context: AgentFrameworkContext): (input: AgentLoopInput) => AgentLoopGenerator;
+
+declare function createAgentToolLoopDefinition(name?: string): AgentLoopDefinition;
+
+type LoadAgentToolLoopScriptOptions = AgentLoopScriptPolicy;
+type AgentToolLoopScriptReference = AgentLoopScriptReference;
+declare function loadAgentToolLoopScript(scriptReference: AgentToolLoopScriptReference, options?: LoadAgentToolLoopScriptOptions): Promise<AgentToolLoopScript>;
+
+/**
+ * Built-in loop registrations — installed at startup so getLoopRegistry().createRunner('agent-tool-loop') works.
+ *
+ * This module allows hosts to skip manual registerLoop() for the built-in loop types.
+ * Hosts can still override by calling registerLoop() with the same id after.
+ */
+declare const AGENT_TOOL_LOOP_ID = "agent-tool-loop";
+declare const AGENT_AGENT_LOOP_ID: string;
+/**
+ * Register the default built-in loops (agent-tool-loop and agent-agent-loop) with the loop registry.
+ * Safe to call multiple times — skips already-registered loops.
+ */
+declare function registerBuiltinLoops(): void;
+
+/**
+ * Builtin tool plugins — registers core tools as LoopPlugin entries.
+ *
+ * Each tool is a separate LoopPlugin that can be overridden by user/host plugins
+ * with the same id. The plugin.install callback calls the tool registry to
+ * register the tool implementation.
+ *
+ * These are registered in the loop registry at startup and loaded by
+ * `registerBuiltinTools` via plugin discovery.
+ */
+
+declare const PLUGIN_MCP_CLIENT = "builtin:mcp-client";
+declare const PLUGIN_MCP_FORWARD = "builtin:mcp-forward";
+declare const PLUGIN_ORCHESTRATION = "builtin:orchestration";
+declare const PLUGIN_SPAWN_AGENT = "builtin:spawn-agent";
+declare const PLUGIN_REMOTE_AGENT = "builtin:remote-agent";
+declare const PLUGIN_ASK_QUESTION = "builtin:ask-question";
+declare const PLUGIN_TODO_WRITE = "builtin:todo-write";
+declare const PLUGIN_ASK_USER_QUESTION = "builtin:ask-user-question";
+declare const PLUGIN_TASK = "builtin:task";
+declare const BUILTIN_TOOL_PLUGIN_IDS: readonly ["builtin:mcp-client", "builtin:mcp-forward", "builtin:orchestration", "builtin:spawn-agent", "builtin:remote-agent", "builtin:ask-question", "builtin:todo-write", "builtin:ask-user-question", "builtin:task"];
+declare function getBuiltinToolPlugins(): LoopPlugin[];
+/** Register all builtin tool plugins with the loop registry. */
+declare function registerBuiltinToolPlugins(): void;
+
+/**
+ * Agent loop registry.
+ *
+ * Discovers, registers, and resolves loop types, loop profiles, and loop plugins.
+ * Core does NOT hard-import any loop implementation; all are registered by host or plugin.
+ */
+
+type LoopPluginSelection = string | LoopProfilePluginEntry;
+declare class LoopRegistryImpl {
+    private readonly loops;
+    private readonly profiles;
+    private readonly plugins;
+    registerLoop(definition: AgentLoopDefinition): void;
+    getLoop(id: string): AgentLoopDefinition | undefined;
+    listLoops(): AgentLoopDefinition[];
+    registerProfile(profile: LoopProfile): void;
+    getProfile(id: string): LoopProfile | undefined;
+    listProfiles(): LoopProfile[];
+    registerPlugin(plugin: LoopPlugin): void;
+    getPlugin(id: string): LoopPlugin | undefined;
+    listPlugins(): LoopPlugin[];
+    installPluginsForLoop(loopId: string, target: {
+        [key: string]: unknown;
+    }, selected?: LoopPluginSelection[]): void;
+    installPluginsForProfile(profile: LoopProfile, target: {
+        [key: string]: unknown;
+    }): void;
+    createRunnerForProfile(profile: LoopProfile, context?: {
+        [key: string]: unknown;
+    }): ((input: AgentLoopInput) => AgentLoopGenerator) | null;
+    createRunner(loopId: string, context?: {
+        [key: string]: unknown;
+    }): ((input: AgentLoopInput) => AgentLoopGenerator) | null;
+    reset(): void;
+}
+declare function getLoopRegistry(): LoopRegistryImpl;
+declare function resetLoopRegistry(): void;
+
+interface TokenTrackerConfig {
+    /** Maximum context window in tokens (default: 200000) */
+    contextWindow?: number;
+    /** Trigger compaction when usage exceeds this fraction (default: 0.90) */
+    compactionThreshold?: number;
+    /** Buffer tokens reserved for output (default: 16000) */
+    outputBuffer?: number;
+}
+interface TokenUsage {
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+    contextWindow: number;
+    usagePercent: number;
+    shouldCompact: boolean;
+}
+/**
+ * Tracks token usage and decides when to trigger auto-compaction.
+ */
+declare class TokenTracker {
+    private promptTokens;
+    private completionTokens;
+    private readonly contextWindow;
+    private readonly compactionThreshold;
+    private readonly outputBuffer;
+    private compacting;
+    private consecutiveCompactionFailures;
+    private maxConsecutiveFailures;
+    constructor(config?: TokenTrackerConfig);
+    /** Record token usage from an LLM response */
+    recordUsage(promptTokens: number, completionTokens: number): void;
+    /** Manually set the prompt token count (e.g., from estimation) */
+    setPromptTokens(tokens: number): void;
+    /** Get current usage */
+    getUsage(): TokenUsage;
+    /** Check if auto-compaction should be triggered */
+    shouldTriggerCompaction(): boolean;
+    /** Mark that compaction is starting */
+    markCompactionStart(): void;
+    /** Mark that compaction succeeded — reset token counts */
+    markCompactionSuccess(estimatedPostTokens: number): void;
+    /** Mark that compaction failed */
+    markCompactionFailure(): void;
+    /** Reset all counters */
+    reset(): void;
+    /** Get a human-readable summary */
+    formatUsage(): string;
+}
+
+/**
+ * Hook registry for managing lifecycle hook handlers.
+ * Hooks execute in registration order (first registered, first executed).
+ *
+ * Converted from module-level singletons to an instance class for test isolation
+ * and multi-runtime support. Backward-compatible function exports delegate to a
+ * default global instance.
+ */
+
+/**
+ * Instance-level hook registry. Each instance maintains its own handler state.
+ */
+declare class HookRegistry {
+    private readonly hookRegistry;
+    private readonly hookOrder;
+    /**
+     * Register a hook handler for a specific lifecycle event.
+     */
+    registerHook(type: HookType, handler: HookHandler, name?: string): void;
+    /**
+     * Unregister a specific hook handler by name.
+     */
+    unregisterHook(type: HookType, name: string): boolean;
+    /**
+     * Execute all registered hooks for a given type in registration order.
+     */
+    executeHooks(type: HookType, context: HookContext, data: Record<string, unknown>): Promise<HookResult>;
+    /**
+     * Check if any hooks are registered for a given type.
+     */
+    hasHooks(type: HookType): boolean;
+    /**
+     * Remove all registered hooks of all types.
+     */
+    clearHooks(): void;
+    /**
+     * List all hook types that have at least one registered handler.
+     */
+    listRegisteredHookTypes(): HookType[];
+    /**
+     * Get the count of registered handlers for a hook type.
+     */
+    getHookCount(type: HookType): number;
+}
+declare function getDefaultHookRegistry(): HookRegistry;
+declare function registerHook(type: HookType, handler: HookHandler, name?: string): void;
+declare function unregisterHook(type: HookType, name: string): boolean;
+declare function executeHooks(type: HookType, context: HookContext, data: Record<string, unknown>): Promise<HookResult>;
+declare function hasHooks(type: HookType): boolean;
+declare function clearHooks(): void;
+declare function listRegisteredHookTypes(): HookType[];
+/**
+ * Get the count of registered handlers for a hook type.
+ */
+declare function getHookCount(type: HookType): number;
+
+/**
+ * 注册内置 prompt 插件（fullReplacement、dynamicPosition）。
+ * @param target 若传入（如节点 `ToolRegistry` 上的 Map），只写入该表；否则写入活动注册表（全局或 ALS）。
+ */
+declare function registerBuiltinPromptPlugins(target?: Map<string, PromptConcatTool>): void;
+
+/** 扁平化后的 LLM 消息（不依赖 peer `ai` 包导出，避免 d.ts 与 SDK 主版本不一致） */
+type PromptFlatModelMessage = {
+    role: 'system' | 'user' | 'assistant' | 'tool';
+    content: unknown;
+};
+declare function findPromptById(prompts: PromptNode[], id: string): {
+    prompt: PromptNode;
+    parent: PromptNode[];
+    index: number;
+} | undefined;
+declare function flattenPrompts(prompts: PromptNode[]): PromptFlatModelMessage[];
+interface PromptConcatPluginPreview {
+    id: string;
+    toolId?: string;
+    caption?: string;
+}
+interface PromptConcatStreamState {
+    processedPrompts: PromptNode[];
+    flatPrompts: PromptFlatModelMessage[];
+    step: 'flatten' | 'complete' | 'plugin' | 'finalize';
+    isComplete: boolean;
+    /** prompt 节点 id → JSON 路径（如 agentFrameworkConfig.prompts.0） */
+    sourcePaths?: Record<string, string>;
+    /** Desktop UI: plugin currently being processed. */
+    currentPlugin?: PromptConcatPluginPreview;
+    /** Desktop UI: progress value between 0 and 1. */
+    progress?: number;
+}
+interface PromptConcatOptions {
+    readAttachmentFile?: (path: string) => Promise<Uint8Array>;
+}
+declare function promptConcatStream(agentConfig: Pick<AgentPromptDescription, 'agentFrameworkConfig'>, messages: ChatMessage[], agentFrameworkContext: AgentFrameworkContext, options?: PromptConcatOptions): AsyncGenerator<PromptConcatStreamState, PromptConcatStreamState, unknown>;
+
+export { createAgentToolLoopDefinition as $, AGENT_AGENT_LOOP_ID as A, BUILTIN_AGENT_AGENT_LOOP_ARTIFACT_RESOURCE_LIFECYCLE_SCRIPT_ID as B, BUILTIN_TOOL_PLUGIN_IDS as C, type CompactionOptions as D, type CompactionResult as E, type LoadAgentToolLoopScriptOptions as F, LoopRegistryImpl as G, HookRegistry as H, PLUGIN_ASK_USER_QUESTION as I, PLUGIN_MCP_CLIENT as J, PLUGIN_MCP_FORWARD as K, type LoadAgentAgentLoopScriptOptions as L, PLUGIN_ORCHESTRATION as M, PLUGIN_REMOTE_AGENT as N, PLUGIN_SPAWN_AGENT as O, PLUGIN_ASK_QUESTION as P, PLUGIN_TASK as Q, PLUGIN_TODO_WRITE as R, type PromptConcatPluginPreview as S, type PromptConcatStreamState as T, TokenTracker as U, autoCompact as V, builtinAgentAgentLoopSources as W, builtinAgentToolLoopSources as X, clearHooks as Y, compactMessages as Z, createAgentAgentLoopDefinition as _, AGENT_TOOL_LOOP_ID as a, createAgentToolLoopRunner as a0, executeHooks as a1, findPromptById as a2, flattenPrompts as a3, getAgentAgentLoopId as a4, getBuiltinAgentAgentLoopSource as a5, getBuiltinAgentToolLoopSource as a6, getBuiltinToolPlugins as a7, getDefaultHookRegistry as a8, getHookCount as a9, getLoopRegistry as aa, hasHooks as ab, listRegisteredHookTypes as ac, loadAgentAgentLoopScript as ad, loadAgentToolLoopScript as ae, promptConcatStream as af, registerBuiltinLoops as ag, registerBuiltinPromptPlugins as ah, registerBuiltinToolPlugins as ai, registerHook as aj, resetLoopRegistry as ak, shouldCompact as al, unregisterHook as am, type AgentAgentBatchRunInput as b, type AgentAgentBatchRunResult as c, type AgentAgentConfigEntry as d, type AgentAgentContext as e, type AgentAgentDescriptor as f, type AgentAgentFormatResultsOptions as g, type AgentAgentLoopContext as h, type AgentAgentLoopScript as i, type AgentAgentLoopScriptArguments as j, type AgentAgentLoopScriptReference as k, type AgentAgentRunAgentFailure as l, type AgentAgentRunAgentInput as m, type AgentAgentRunAgentResult as n, type AgentAgentScriptContext as o, type AgentToolLoopContext as p, type AgentToolLoopIterationGenerator as q, type AgentToolLoopIterationResult as r, type AgentToolLoopScript as s, type AgentToolLoopScriptContext as t, type AgentToolLoopScriptReference as u, type AgentToolLoopState as v, type AgentToolLoopTurnStartResult as w, BUILTIN_AGENT_AGENT_LOOP_DECLARATIVE_AGENT_RUN_SCRIPT_ID as x, BUILTIN_AGENT_AGENT_LOOP_QUALITY_GATE_SCRIPT_ID as y, BUILTIN_AGENT_TOOL_LOOP_DEFAULT_SCRIPT_ID as z };

package/dist/providerRegistry-Bi6pAvSj.d.ts

@@ -0,0 +1,86 @@
+import { m as AgentDefinition } from './interface-IrKBFtL1.js';
+import { k as ILLMProvider } from './scriptDeploymentPipeline-CXJcC82H.js';
+
+/**
+ * Extended agent definition used by the agent profile registry.
+ * Wraps the protocol-level AgentDefinition with additional runtime metadata.
+ */
+interface AgentProfile {
+    /** Unique ID for this agent (matches protocol id convention like "memeloop:build") */
+    id: string;
+    /** Display name */
+    name: string;
+    /** Agent type / role */
+    type: AgentProfileType;
+    /** System prompt / instructions for the agent */
+    prompt: string;
+    /** Tool permission rules (mutually exclusive with permissive defaults) */
+    permissions: ToolPermissionRules;
+    /** Optional model override (provider/model string) */
+    model?: string;
+    /** Underlying protocol-compatible definition for framework integration */
+    protocolDef: AgentDefinition;
+}
+type AgentProfileType = 'build' | 'plan' | 'explore' | 'oracle' | 'librarian';
+interface ToolPermissionRules {
+    /** Default action for tools not matching any rule */
+    default: 'allow' | 'ask' | 'deny';
+    /** Per-tool or wildcard rules */
+    rules: Array<{
+        pattern: string;
+        action: 'allow' | 'ask' | 'deny';
+    }>;
+}
+/**
+ * Build agent: full access, default model.
+ * Primary agent for executing tasks, writing code, running commands.
+ */
+declare const buildAgent: AgentProfile;
+/**
+ * Plan agent: read-only, denies file edits and terminal execution.
+ * Used for high-level planning and task decomposition.
+ */
+declare const planAgent: AgentProfile;
+/**
+ * Explore agent: read + search tools only.
+ * Fast search and codebase exploration without modification.
+ */
+declare const exploreAgent: AgentProfile;
+/**
+ * Oracle agent: read-only, for architecture consultation and code review.
+ */
+declare const oracleAgent: AgentProfile;
+/**
+ * Librarian agent: read + web search tools only.
+ * External documentation lookup and context gathering.
+ */
+declare const librarianAgent: AgentProfile;
+/** Built-in agent profiles used by the task delegation tool. */
+declare const BUILTIN_AGENT_PROFILES: AgentProfile[];
+
+interface ProviderConfig {
+    name: string;
+    baseUrl?: string;
+    apiKey?: string;
+}
+interface RegisteredProvider {
+    provider: ILLMProvider;
+    config: ProviderConfig;
+}
+declare class ProviderRegistry {
+    private providers;
+    register(provider: ILLMProvider, config?: Omit<ProviderConfig, 'name'>): void;
+    unregister(name: string): void;
+    get(name: string): ILLMProvider | undefined;
+    getConfig(name: string): ProviderConfig | undefined;
+    upsertConfig(config: ProviderConfig): void;
+    list(): string[];
+    listConfigs(): ProviderConfig[];
+    resolve(modelId: string): {
+        provider: ILLMProvider;
+        providerName: string;
+        modelName?: string;
+    };
+}
+
+export { type AgentProfile as A, BUILTIN_AGENT_PROFILES as B, type ProviderConfig as P, type RegisteredProvider as R, type ToolPermissionRules as T, type AgentProfileType as a, ProviderRegistry as b, buildAgent as c, exploreAgent as e, librarianAgent as l, oracleAgent as o, planAgent as p };