@jungjaehoon/mama-core 2.4.1 → 4.0.0

package/dist/runtime/post-tool-handler.js

@@ -0,0 +1,137 @@
+"use strict";
+/**
+ * After a tool runs, turn what it wrote into memory records, bounded and deduplicated,
+ * and fire-and-forget.
+ *
+ * What is here is the mechanism: notice that an editing tool ran, find the file it
+ * touched and the content it produced, ask for candidate records, keep at most a
+ * stated number of them, skip the ones already stored, and write the rest. What a
+ * candidate *is* is not here. A candidate is vocabulary, and vocabulary belongs to
+ * the caller: it supplies the source, and it names the two tools this handler calls.
+ *
+ * With no source, the handler is inert. That is the intended resting state once the
+ * caller's own extractor is gone.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostToolHandler = void 0;
+const DEFAULT_SAVE_LIMIT = 20;
+class PostToolHandler {
+    executeTool;
+    enabled;
+    editTools;
+    searchTool;
+    saveTool;
+    saveLimit;
+    source;
+    constructor(executeTool, config, source = null) {
+        this.executeTool = executeTool;
+        this.enabled = config.enabled;
+        this.editTools = config.editTools;
+        this.searchTool = config.searchTool;
+        this.saveTool = config.saveTool;
+        this.saveLimit = config.saveLimit ?? DEFAULT_SAVE_LIMIT;
+        this.source = source;
+    }
+    /**
+     * Called from the tool-result path. MUST NOT be async, MUST NOT return a promise
+     * and MUST NOT throw: a memory write is not allowed to decide whether a turn
+     * continues. The task is registered so the turn can still wait for it.
+     */
+    processInBackground(toolName, input, result, executionContext) {
+        if (!this.enabled || !this.source) {
+            return;
+        }
+        const task = this.processAsync(toolName, input, result, executionContext);
+        executionContext?.backgroundTasks?.register(task);
+        void task.catch(() => { });
+    }
+    async processAsync(toolName, input, result, executionContext) {
+        if (!this.enabled || !this.source) {
+            return;
+        }
+        if (!this.isEditTool(toolName)) {
+            return;
+        }
+        const filePath = this.extractFilePath(input);
+        if (!filePath) {
+            return;
+        }
+        const content = this.extractContent(result);
+        if (!content) {
+            return;
+        }
+        const candidates = this.source.candidates(content, filePath);
+        if (candidates.length === 0) {
+            return;
+        }
+        for (const candidate of candidates.slice(0, this.saveLimit)) {
+            const isDupe = await this.isDuplicate(candidate, executionContext);
+            if (isDupe) {
+                continue;
+            }
+            await this.save(candidate, executionContext);
+        }
+    }
+    isEditTool(toolName) {
+        return this.editTools.some((tool) => toolName.includes(tool));
+    }
+    extractFilePath(input) {
+        if (!input || typeof input !== 'object') {
+            return undefined;
+        }
+        const obj = input;
+        const raw = obj['path'] ?? obj['file_path'] ?? obj['filePath'];
+        return typeof raw === 'string' ? raw : undefined;
+    }
+    extractContent(result) {
+        if (typeof result === 'string') {
+            return result.length > 0 ? result : undefined;
+        }
+        if (result && typeof result === 'object') {
+            const obj = result;
+            if (typeof obj['content'] === 'string' && obj['content'].length > 0) {
+                return obj['content'];
+            }
+            const serialized = JSON.stringify(result);
+            return serialized.length > 2 ? serialized : undefined;
+        }
+        return undefined;
+    }
+    async isDuplicate(candidate, executionContext) {
+        try {
+            const input = { query: candidate.topic, type: 'decision', limit: 3 };
+            const response = (await (executionContext
+                ? this.executeTool(this.searchTool, input, executionContext)
+                : this.executeTool(this.searchTool, input)));
+            if (!response?.results || response.results.length === 0) {
+                return false;
+            }
+            return response.results.some((item) => item.topic === candidate.topic && item.decision === candidate.decision);
+        }
+        catch {
+            return false;
+        }
+    }
+    async save(candidate, executionContext) {
+        try {
+            const input = {
+                type: 'decision',
+                topic: candidate.topic,
+                decision: candidate.decision,
+                reasoning: candidate.reasoning,
+                confidence: candidate.confidence,
+            };
+            if (executionContext) {
+                await this.executeTool(this.saveTool, input, executionContext);
+            }
+            else {
+                await this.executeTool(this.saveTool, input);
+            }
+        }
+        catch {
+            // A memory write that fails must not fail the turn that produced it.
+        }
+    }
+}
+exports.PostToolHandler = PostToolHandler;
+//# sourceMappingURL=post-tool-handler.js.map

package/dist/runtime/prompt-layers.d.ts

@@ -0,0 +1,126 @@
+/**
+ * A system prompt as LAYERS, and what it costs to send them.
+ *
+ * A caller states the layers - what the agent is, what it may call, what it is
+ * recovering - and this joins them under a token budget, dropping or trimming the
+ * expendable ones first. The caller never joins or trims: doing that on the consumer
+ * side is how a prompt becomes a concatenation nobody owns.
+ *
+ * Uses js-tiktoken for accurate token counting (STORY-007).
+ */
+/** The three thresholds a caller may state. Defaults are the ones MAMA shipped with. */
+export interface PromptBudget {
+    /** Warn beyond this many tokens. */
+    warnTokens?: number;
+    /** Begin truncating beyond this many tokens. */
+    truncateTokens?: number;
+    /** Anything beyond this is force-truncated. */
+    hardLimitTokens?: number;
+}
+/**
+ * State the budget once, at wiring time. The thresholds are a consumer's setting;
+ * the arithmetic is not.
+ */
+export declare function setPromptBudget(next: PromptBudget): void;
+/**
+ * A named layer of the system prompt with a priority level.
+ *
+ * Priority levels:
+ * - 1: CLAUDE.md (NEVER truncate)
+ * - 2: Gateway Tools (extreme truncation only)
+ * - 3: Context Prompt (regeneratable)
+ * - 4: AGENTS.md (can re-read from file)
+ * - 5: Rules (can read file on demand)
+ * - 6: Keyword Instructions (ephemeral, safe to drop)
+ */
+export interface PromptLayer {
+    /** Layer identifier for diagnostics */
+    name: string;
+    /** Layer content */
+    content: string;
+    /**
+     * Priority level (1 = highest / never truncate, 6 = lowest / drop first).
+     *
+     * 1 = CLAUDE.md (NEVER truncate)
+     * 2 = Gateway Tools (extreme only)
+     * 3 = Context Prompt (regeneratable)
+     * 4 = AGENTS.md (can re-read)
+     * 5 = Rules (can read file)
+     * 6 = Keyword Instructions (ephemeral)
+     */
+    priority: number;
+    /** Host-authored opening marker paired atomically with protectedSuffix. */
+    protectedPrefix?: string;
+    /** Host-authored closing marker that must survive partial truncation. */
+    protectedSuffix?: string;
+}
+/**
+ * Result of a prompt size check or enforcement pass.
+ */
+export interface MonitorResult {
+    /** Total character count across all layers */
+    totalChars: number;
+    /** @deprecated Use totalTokens instead. This uses chars/4 heuristic. */
+    estimatedTokens: number;
+    /** Actual token count via tiktoken (or byte-length fallback) */
+    totalTokens: number;
+    /** Whether total is within the truncation threshold */
+    withinBudget: boolean;
+    /** Warning message if approaching or exceeding limits, null otherwise */
+    warning: string | null;
+    /** Names of layers that were truncated or removed */
+    truncatedLayers: string[];
+}
+/**
+ * Monitors and enforces system prompt size limits using token counting.
+ *
+ * Uses a priority-based truncation strategy: layers with higher priority
+ * numbers (lower importance) are truncated first. Priority 1 layers are
+ * never truncated. Within the same priority, larger layers are truncated first.
+ *
+ * @example
+ * ```typescript
+ * const monitor = new PromptSizeMonitor();
+ * const result = monitor.check(layers);
+ * if (!result.withinBudget) {
+ *   const { layers: trimmed } = monitor.enforce(layers);
+ * }
+ * ```
+ */
+export declare class PromptSizeMonitor {
+    /**
+     * Check prompt layers for size and return diagnostic info without modifying them.
+     *
+     * @param layers - Prompt layers to analyze
+     * @returns Monitor result with size metrics and warnings
+     */
+    check(layers: PromptLayer[]): MonitorResult;
+    /**
+     * Enforce size limits by truncating layers in priority order.
+     *
+     * Layers with higher priority numbers (lower importance) are removed first.
+     * Within the same priority level, larger layers are removed first.
+     * Priority 1 layers are never truncated.
+     *
+     * @param layers - Prompt layers to enforce limits on
+     * @param maxTokens - Maximum allowed tokens (defaults to TRUNCATE_TOKENS)
+     * @returns Object with truncated layers array and updated monitor result
+     */
+    enforce(layers: PromptLayer[], maxTokens?: number): {
+        layers: PromptLayer[];
+        result: MonitorResult;
+    };
+    /**
+     * @deprecated Use countTokens() from token-estimator instead.
+     * Estimate token count from character count using chars/4 heuristic.
+     */
+    estimateTokens(chars: number): number;
+}
+/** How joined layers are separated. One separator, stated once. */
+export declare const PROMPT_LAYER_SEPARATOR = "\n\n---\n\n";
+/**
+ * Join the stated layers into one prompt, trimming the expendable ones if the budget
+ * says so. Empty layers never reach the model, and an empty list is an empty prompt.
+ */
+export declare function composeLayers(layers: readonly PromptLayer[], onDiagnostic?: (message: string) => void): string;
+//# sourceMappingURL=prompt-layers.d.ts.map

package/dist/runtime/prompt-layers.js

@@ -0,0 +1,239 @@
+"use strict";
+/**
+ * A system prompt as LAYERS, and what it costs to send them.
+ *
+ * A caller states the layers - what the agent is, what it may call, what it is
+ * recovering - and this joins them under a token budget, dropping or trimming the
+ * expendable ones first. The caller never joins or trims: doing that on the consumer
+ * side is how a prompt becomes a concatenation nobody owns.
+ *
+ * Uses js-tiktoken for accurate token counting (STORY-007).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROMPT_LAYER_SEPARATOR = exports.PromptSizeMonitor = void 0;
+exports.setPromptBudget = setPromptBudget;
+exports.composeLayers = composeLayers;
+const token_estimator_js_1 = require("./token-estimator.js");
+let budget = {
+    warnTokens: 3_750,
+    truncateTokens: 6_250,
+    hardLimitTokens: 10_000,
+};
+/**
+ * State the budget once, at wiring time. The thresholds are a consumer's setting;
+ * the arithmetic is not.
+ */
+function setPromptBudget(next) {
+    budget = {
+        warnTokens: next.warnTokens ?? budget.warnTokens,
+        truncateTokens: next.truncateTokens ?? budget.truncateTokens,
+        hardLimitTokens: next.hardLimitTokens ?? budget.hardLimitTokens,
+    };
+}
+/** Token count at which a warning is emitted */
+const WARN_TOKENS = () => budget.warnTokens;
+/** Token count at which truncation begins */
+const TRUNCATE_TOKENS = () => budget.truncateTokens;
+/** Absolute maximum - anything beyond is force-truncated */
+const HARD_LIMIT_TOKENS = () => budget.hardLimitTokens;
+/**
+ * Monitors and enforces system prompt size limits using token counting.
+ *
+ * Uses a priority-based truncation strategy: layers with higher priority
+ * numbers (lower importance) are truncated first. Priority 1 layers are
+ * never truncated. Within the same priority, larger layers are truncated first.
+ *
+ * @example
+ * ```typescript
+ * const monitor = new PromptSizeMonitor();
+ * const result = monitor.check(layers);
+ * if (!result.withinBudget) {
+ *   const { layers: trimmed } = monitor.enforce(layers);
+ * }
+ * ```
+ */
+class PromptSizeMonitor {
+    /**
+     * Check prompt layers for size and return diagnostic info without modifying them.
+     *
+     * @param layers - Prompt layers to analyze
+     * @returns Monitor result with size metrics and warnings
+     */
+    check(layers) {
+        const totalChars = layers.reduce((sum, layer) => sum + layer.content.length, 0);
+        const combined = layers.map((l) => l.content).join('');
+        const totalTokens = (0, token_estimator_js_1.countTokens)(combined);
+        const estimatedTokens = this.estimateTokens(totalChars);
+        const truncatedLayers = [];
+        let warning = null;
+        let withinBudget = true;
+        if (totalTokens > HARD_LIMIT_TOKENS()) {
+            warning =
+                `System prompt exceeds hard limit: ${totalTokens} tokens ` +
+                    `(${totalChars} chars) > ${HARD_LIMIT_TOKENS()} token limit. ` +
+                    `Force truncation required.`;
+            withinBudget = false;
+        }
+        else if (totalTokens > TRUNCATE_TOKENS()) {
+            warning =
+                `System prompt exceeds truncation threshold: ${totalTokens} tokens ` +
+                    `(${totalChars} chars) > ${TRUNCATE_TOKENS()} token limit. ` +
+                    `Truncation recommended.`;
+            withinBudget = false;
+        }
+        else if (totalTokens > WARN_TOKENS()) {
+            warning =
+                `System prompt approaching limit: ${totalTokens} tokens ` +
+                    `(${totalChars} chars) > ${WARN_TOKENS()} token warning threshold.`;
+            withinBudget = true;
+        }
+        return { totalChars, estimatedTokens, totalTokens, withinBudget, warning, truncatedLayers };
+    }
+    /**
+     * Enforce size limits by truncating layers in priority order.
+     *
+     * Layers with higher priority numbers (lower importance) are removed first.
+     * Within the same priority level, larger layers are removed first.
+     * Priority 1 layers are never truncated.
+     *
+     * @param layers - Prompt layers to enforce limits on
+     * @param maxTokens - Maximum allowed tokens (defaults to TRUNCATE_TOKENS)
+     * @returns Object with truncated layers array and updated monitor result
+     */
+    enforce(layers, maxTokens = TRUNCATE_TOKENS()) {
+        // Count tokens per layer
+        const layerTokens = layers.map((l) => (0, token_estimator_js_1.countTokens)(l.content));
+        const totalTokens = layerTokens.reduce((sum, t) => sum + t, 0);
+        if (totalTokens <= maxTokens) {
+            const checkResult = this.check(layers);
+            return {
+                layers: [...layers],
+                result: { ...checkResult, withinBudget: totalTokens <= maxTokens },
+            };
+        }
+        // Sort candidates for truncation: highest priority number first, then largest first
+        const sortedByExpendability = layers
+            .map((layer, index) => ({ layer, index, tokens: layerTokens[index] }))
+            .filter(({ layer }) => layer.priority > 1)
+            .sort((a, b) => {
+            if (b.layer.priority !== a.layer.priority) {
+                return b.layer.priority - a.layer.priority;
+            }
+            return b.tokens - a.tokens;
+        });
+        const truncatedLayers = [];
+        const resultLayers = [...layers];
+        let currentTokens = totalTokens;
+        for (const { layer, index, tokens } of sortedByExpendability) {
+            if (currentTokens <= maxTokens) {
+                break;
+            }
+            const excess = currentTokens - maxTokens;
+            if (tokens <= excess) {
+                // Full removal
+                currentTokens -= tokens;
+                resultLayers[index] = { ...layer, content: '' };
+                truncatedLayers.push(layer.name);
+            }
+            else {
+                // Partial truncation: estimate chars to remove based on layer's token density
+                const truncationMarker = `\n\n[... ${layer.name} truncated: ~${excess} tokens removed ...]`;
+                const protectedSuffix = layer.protectedSuffix && layer.content.endsWith(layer.protectedSuffix)
+                    ? `\n${layer.protectedSuffix}`
+                    : '';
+                const protectedTail = `${truncationMarker}${protectedSuffix}`;
+                const markerTokens = (0, token_estimator_js_1.countTokens)(protectedTail);
+                const protectedPrefix = layer.protectedPrefix && layer.content.startsWith(layer.protectedPrefix)
+                    ? layer.protectedPrefix
+                    : '';
+                const hasProtectedPair = protectedPrefix.length > 0 && protectedSuffix.length > 0;
+                const availableLayerTokens = Math.max(0, maxTokens - (currentTokens - tokens));
+                const minimumProtectedContent = `${protectedPrefix}${protectedTail}`;
+                if (markerTokens >= excess ||
+                    (hasProtectedPair && (0, token_estimator_js_1.countTokens)(minimumProtectedContent) > availableLayerTokens)) {
+                    // The truncation marker or atomic host marker pair cannot fit safely.
+                    currentTokens -= tokens;
+                    resultLayers[index] = { ...layer, content: '' };
+                    truncatedLayers.push(layer.name);
+                }
+                else {
+                    const charsPerToken = tokens > 0 ? layer.content.length / tokens : 4;
+                    const charsToRemove = Math.ceil(excess * charsPerToken);
+                    const safeKeep = Math.max(0, layer.content.length - charsToRemove - protectedTail.length);
+                    let newContent = layer.content.slice(0, Math.max(safeKeep, protectedPrefix.length)) + protectedTail;
+                    if (hasProtectedPair && (0, token_estimator_js_1.countTokens)(newContent) > availableLayerTokens) {
+                        newContent = minimumProtectedContent;
+                    }
+                    const newTokens = (0, token_estimator_js_1.countTokens)(newContent);
+                    resultLayers[index] = {
+                        ...layer,
+                        content: newContent,
+                    };
+                    currentTokens = currentTokens - tokens + newTokens;
+                    truncatedLayers.push(layer.name);
+                }
+            }
+        }
+        const finalLayers = resultLayers.filter((layer) => layer.content.length > 0);
+        const finalCheck = this.check(finalLayers);
+        const withinBudget = finalCheck.totalTokens <= maxTokens;
+        let warning = null;
+        if (!withinBudget) {
+            warning =
+                `System prompt still exceeds limit after truncation: ${finalCheck.totalTokens} tokens. ` +
+                    `Only priority-1 layers remain.`;
+        }
+        else if (truncatedLayers.length > 0) {
+            warning =
+                `Truncated ${truncatedLayers.length} layer(s) to fit within ${maxTokens} tokens: ` +
+                    `${truncatedLayers.join(', ')}.`;
+        }
+        return {
+            layers: finalLayers,
+            result: {
+                ...finalCheck,
+                withinBudget,
+                warning,
+                truncatedLayers,
+            },
+        };
+    }
+    /**
+     * @deprecated Use countTokens() from token-estimator instead.
+     * Estimate token count from character count using chars/4 heuristic.
+     */
+    estimateTokens(chars) {
+        return Math.ceil(chars / 4);
+    }
+}
+exports.PromptSizeMonitor = PromptSizeMonitor;
+/** How joined layers are separated. One separator, stated once. */
+exports.PROMPT_LAYER_SEPARATOR = '\n\n---\n\n';
+/**
+ * Join the stated layers into one prompt, trimming the expendable ones if the budget
+ * says so. Empty layers never reach the model, and an empty list is an empty prompt.
+ */
+function composeLayers(layers, onDiagnostic) {
+    const stated = layers.filter((layer) => layer.content.trim().length > 0);
+    if (stated.length === 0) {
+        return '';
+    }
+    const monitor = new PromptSizeMonitor();
+    const checkResult = monitor.check([...stated]);
+    if (checkResult.warning) {
+        onDiagnostic?.(checkResult.warning);
+    }
+    let effective = stated;
+    if (!checkResult.withinBudget) {
+        const { layers: trimmed, result } = monitor.enforce([...stated]);
+        if (result.truncatedLayers.length > 0) {
+            onDiagnostic?.(`Truncated layers: ${result.truncatedLayers.join(', ')}`);
+        }
+        effective = trimmed;
+    }
+    return effective
+        .filter((layer) => layer.content.length > 0)
+        .map((layer) => layer.content)
+        .join(exports.PROMPT_LAYER_SEPARATOR);
+}
+//# sourceMappingURL=prompt-layers.js.map

package/dist/runtime/runtime-process.d.ts

@@ -0,0 +1,102 @@
+import { EventEmitter } from 'events';
+import type { SubagentBridge, SubagentBridgeRequest } from './subagent-bridge.js';
+import type { SubagentEvent } from './drivers/codex-app-server-process.js';
+export type { SubagentBridge, SubagentBridgeRequest } from './subagent-bridge.js';
+export type { SubagentEvent } from './drivers/codex-app-server-process.js';
+import type { PromptCallbacks as ClaudePromptCallbacks, PromptResult as ClaudePromptResult } from './drivers/types.js';
+import type { IModelRunner, RunnerMetrics, PromptOptions, SessionPolicyStatus, NativeInputReceipt } from './drivers/types.js';
+import { type CodexAuxiliaryToolPolicy } from './drivers/codex-auxiliary-tools.js';
+export interface AgentRuntimeProcess {
+    sendMessage(content: string, callbacks?: ClaudePromptCallbacks): Promise<ClaudePromptResult>;
+    isReady(): boolean;
+    stop(): void | Promise<void>;
+    getSessionId?(): string;
+    on(event: 'idle' | 'close' | 'error', listener: (...args: unknown[]) => void): this;
+}
+export interface CodexRuntimeProcessOptions {
+    defaultSessionKey?: string;
+    model?: string;
+    systemPrompt?: string;
+    cwd?: string;
+    sandbox?: 'read-only' | 'workspace-write' | 'danger-full-access';
+    requestTimeout?: number;
+    codexHome?: string;
+    isolatedHome?: string;
+    registryRoot?: string;
+    mcpConfigPath?: string;
+    command?: string;
+    /** Where this consumer's Codex CLI keeps its credential. The driver copies, never finds. */
+    authSourcePath?: string;
+    /** Managed Codex `model_reasoning_effort`; unset means the built-in default. */
+    effort?: string;
+    /** Enable the managed workspace shell; disabled unless the consumer opts in. */
+    shellTool?: boolean;
+    /** Enable live web search; disabled unless the consumer opts in. */
+    webSearch?: boolean;
+    /** Explicit shell environment overrides supplied by the consumer. */
+    shellEnvironment?: Record<string, string>;
+    /** Complete backend environment; omitted retains normal process inheritance. */
+    processEnv?: NodeJS.ProcessEnv;
+    /** Absolute credential paths the native command sandbox must not read. */
+    deniedReadPaths?: string[];
+    allowLoginShell?: boolean;
+    auxiliaryToolPolicy?: CodexAuxiliaryToolPolicy;
+    /**
+     * Root the driver keeps its files under. The caller names it: a runtime process
+     * does not know which product it is running inside.
+     */
+    hostRootDir: string;
+    /**
+     * Host factory for a child-scoped authority (own model run, own envelope, own bridge).
+     * Forwarded verbatim: a Codex-native child outlives the parent turn and must never
+     * inherit the parent's expiring grant.
+     */
+    createSubagentBridge?: (info: SubagentBridgeRequest) => Promise<SubagentBridge | null>;
+}
+/**
+ * Session-persistent Codex wrapper with the same minimal contract used by
+ * multi-agent runtime (sendMessage/isReady/stop + idle events).
+ *
+ * Implements both AgentRuntimeProcess (multi-agent) and IModelRunner (agent-loop).
+ * Uses one Codex app-server connection and multiplexes durable threads by
+ * session key. Different sessions may run concurrently; turns for the same
+ * session are serialized by CodexAppServerProcess.
+ */
+export declare class CodexRuntimeProcess extends EventEmitter implements AgentRuntimeProcess, IModelRunner {
+    readonly backendType: "codex";
+    /** codex app-server spawns native subagents and reports the spawn via onSubagentStart. */
+    readonly supportsNativeSubagents = true;
+    private readonly options;
+    private readonly appServer;
+    private readonly auxiliaryToolBridge;
+    private defaultSessionKey;
+    private systemPrompt;
+    private stopped;
+    private activeRequests;
+    private subagentCompletionAcceptance;
+    private subagentCompletionAcceptanceRequired;
+    private _requestCount;
+    private _failureCount;
+    private _totalLatencyMs;
+    private _lastRequestAt;
+    constructor(options: CodexRuntimeProcessOptions);
+    /** Synchronous durable acceptance of child completion, before driver cleanup. */
+    registerSubagentCompletionAcceptance(accept: (event: SubagentEvent) => void): () => void;
+    prompt(content: string, callbacks?: ClaudePromptCallbacks, options?: PromptOptions): Promise<ClaudePromptResult>;
+    steer(content: string, target: NativeInputReceipt, options?: Pick<PromptOptions, 'sessionKey' | 'sessionId'> & {
+        beforeSend?: () => void;
+    }): Promise<NativeInputReceipt>;
+    getSessionPolicyStatus(options: PromptOptions): SessionPolicyStatus;
+    resetSession(sessionId?: string, sessionKey?: string): Promise<void>;
+    sendMessage(content: string, callbacks?: ClaudePromptCallbacks): Promise<ClaudePromptResult>;
+    private execute;
+    private notifyError;
+    setSessionId(id: string): void;
+    setSystemPrompt(prompt: string): void;
+    isReady(): boolean;
+    isHealthy(): boolean;
+    getMetrics(): RunnerMetrics;
+    stop(): Promise<void>;
+    getSessionId(): string;
+}
+//# sourceMappingURL=runtime-process.d.ts.map