@agenthippo-ai/agenthippo 1.110.9 → 1.110.19

package/out/runner/protocol.js

@@ -1,108 +0,0 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) AgentHippo.ai. All rights reserved.
- *--------------------------------------------------------------------------------------------*/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isTerminalFrame = isTerminalFrame;
-exports.encodeRunnerFrame = encodeRunnerFrame;
-exports.encodeClientFrame = encodeClientFrame;
-exports.parseRunnerFrame = parseRunnerFrame;
-exports.parseClientFrame = parseClientFrame;
-exports.splitFrames = splitFrames;
-exports.toWireOptions = toWireOptions;
-function isTerminalFrame(frame) {
-    return frame.type === 'result' || frame.type === 'failed';
-}
-function encodeRunnerFrame(frame) {
-    return `${JSON.stringify(frame)}\n`;
-}
-function encodeClientFrame(frame) {
-    return `${JSON.stringify(frame)}\n`;
-}
-/** Parse one runner→serve line. Returns undefined for anything malformed (never throws). */
-function parseRunnerFrame(line) {
-    const parsed = parseObject(line);
-    if (!parsed) {
-        return undefined;
-    }
-    const type = parsed.type;
-    if (type === 'ready') {
-        return { type: 'ready' };
-    }
-    if (type === 'result' && typeof parsed.id === 'string') {
-        return {
-            type: 'result',
-            id: parsed.id,
-            ...(typeof parsed.nativeSessionId === 'string' ? { nativeSessionId: parsed.nativeSessionId } : {}),
-        };
-    }
-    if (type === 'failed' && typeof parsed.id === 'string') {
-        return {
-            type: 'failed',
-            id: parsed.id,
-            message: typeof parsed.message === 'string' ? parsed.message : 'Sandbox turn failed',
-        };
-    }
-    if (type === 'question' && parsed.payload && typeof parsed.payload === 'object') {
-        return { type: 'question', payload: parsed.payload };
-    }
-    // Streamed engine events keep the existing union — validated by shape, not re-listed here.
-    if (typeof type === 'string' && RUNNER_EVENT_TYPES.has(type)) {
-        return parsed;
-    }
-    return undefined;
-}
-/** Parse one serve→runner line. Returns undefined for anything malformed (never throws). */
-function parseClientFrame(line) {
-    const parsed = parseObject(line);
-    if (!parsed) {
-        return undefined;
-    }
-    if (parsed.type === 'run' && typeof parsed.id === 'string' && typeof parsed.message === 'string') {
-        const options = parsed.options && typeof parsed.options === 'object' ? parsed.options : {};
-        return { type: 'run', id: parsed.id, message: parsed.message, options: options };
-    }
-    if (parsed.type === 'abort' && typeof parsed.id === 'string') {
-        return { type: 'abort', id: parsed.id };
-    }
-    return undefined;
-}
-const RUNNER_EVENT_TYPES = new Set([
-    'text', 'thinking', 'toolStart', 'toolEnd', 'progress', 'error', 'done', 'nativeSessionId', 'probe',
-]);
-function parseObject(line) {
-    let parsed;
-    try {
-        parsed = JSON.parse(line);
-    }
-    catch {
-        return undefined;
-    }
-    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
-        return undefined;
-    }
-    return parsed;
-}
-/**
- * Split a byte stream into newline-delimited frames. Returns the parsed lines plus whatever
- * partial text is left over, which the caller carries into the next chunk.
- */
-function splitFrames(buffer) {
-    const parts = buffer.split('\n');
-    const rest = parts.pop() ?? '';
-    return { lines: parts.filter((l) => l.trim().length > 0), rest };
-}
-/**
- * The credential scrub, applied where serve builds a `run` frame. The four secrets that must
- * never cross: `AgentRequestOptions.apiKey` plus `EngineConfig`'s `litellmApiKey` /
- * `openaiApiKey` / `anthropicApiKey` (the latter three live in engine config, which the runner
- * builds in-sandbox from `baseUrl` + `modelToken` — they are never sent).
- */
-function toWireOptions(options, model) {
-    const { apiKey: _dropped, ...rest } = options;
-    return {
-        ...rest,
-        ...(model.baseUrl ? { baseUrl: model.baseUrl } : {}),
-        ...(model.modelToken ? { modelToken: model.modelToken } : {}),
-    };
-}

package/out/runner/remoteEngine.js

@@ -1,130 +0,0 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) AgentHippo.ai. All rights reserved.
- *--------------------------------------------------------------------------------------------*/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RemoteEngine = void 0;
-/**
- * `RemoteEngine` (PLAN/serve-v4-clean.md §3): satisfies `AgentEngine` by forwarding the turn to
- * a runner inside a sandbox. serve's turn loop, streaming, rate limiting and session handling do
- * not change — this is the same move `RemoteDataPlane` (`cli/data-plane/remote.ts`) already
- * makes against the in-process `DataPlane`, one layer up.
- */
-const customEngineIpc_1 = require("../engines/customEngineIpc");
-const protocol_1 = require("./protocol");
-class RemoteEngine {
-    id;
-    displayName;
-    channel;
-    model;
-    logger;
-    /** Per-run sinks, keyed by run id — the protocol multiplexes turns on one channel. */
-    pending = new Map();
-    buffer = '';
-    seq = 0;
-    wired = false;
-    constructor(opts) {
-        this.id = opts.id;
-        this.displayName = opts.displayName;
-        this.channel = opts.channel;
-        this.model = opts.model ?? {};
-        this.logger = opts.logger;
-    }
-    async stream(message, options, emitter, _runtime, signal) {
-        this.wire();
-        const id = `r${++this.seq}`;
-        const settled = new Promise((resolve, reject) => {
-            this.pending.set(id, { emitter, resolve, reject });
-        });
-        const onAbort = () => { this.send({ type: 'abort', id }); };
-        if (signal) {
-            if (signal.aborted) {
-                onAbort();
-            }
-            else {
-                signal.addEventListener('abort', onAbort, { once: true });
-            }
-        }
-        try {
-            // A fresh warrant for this turn when the caller can mint one; the create-time token is
-            // the fallback for paths that mint nothing (tier 0, tests).
-            const modelToken = this.model.mintToken
-                ? (await this.model.mintToken()) ?? this.model.modelToken
-                : this.model.modelToken;
-            this.send({
-                type: 'run',
-                id,
-                message,
-                options: (0, protocol_1.toWireOptions)(options, { ...this.model, modelToken }),
-            });
-            // Resolves on the TERMINAL frame (result/failed) — never on the streamed `done`,
-            // which engines emit mid-run.
-            await settled;
-        }
-        finally {
-            this.pending.delete(id);
-            signal?.removeEventListener('abort', onAbort);
-        }
-    }
-    /** No-op by design: the runner drives its own maintenance timer in-sandbox (see runner/host.ts). */
-    onMaintenance() { }
-    /** Sandbox teardown is the driver's job (`destroy(handle)` at session end), not the engine's. */
-    dispose() { }
-    wire() {
-        if (this.wired) {
-            return;
-        }
-        this.wired = true;
-        this.channel.input.on('data', (chunk) => {
-            this.buffer += typeof chunk === 'string' ? chunk : chunk.toString('utf8');
-            const { lines, rest } = (0, protocol_1.splitFrames)(this.buffer);
-            this.buffer = rest;
-            for (const line of lines) {
-                const frame = (0, protocol_1.parseRunnerFrame)(line);
-                if (!frame) {
-                    this.logger?.warn('[RemoteEngine] dropped malformed runner frame');
-                    continue;
-                }
-                void this.dispatch(frame);
-            }
-        });
-        void this.channel.closed?.then(() => this.failAll(new Error('sandbox channel closed')), (err) => this.failAll(err instanceof Error ? err : new Error(String(err))));
-    }
-    async dispatch(frame) {
-        if (frame.type === 'ready') {
-            return;
-        }
-        if (frame.type === 'result') {
-            this.pending.get(frame.id)?.resolve(frame.nativeSessionId);
-            return;
-        }
-        if (frame.type === 'failed') {
-            this.pending.get(frame.id)?.reject(new Error(frame.message));
-            return;
-        }
-        // Streamed events fan out to every in-flight emitter. In the sandbox model a runner hosts
-        // exactly one session, so in practice there is one — but the run id is not carried on
-        // streamed events (matching the existing worker protocol), so this stays a broadcast.
-        for (const entry of this.pending.values()) {
-            if (frame.type === 'question') {
-                // One-way notification; the runner already answered it `declined` locally.
-                await entry.emitter.question(frame.payload).catch(() => undefined);
-                continue;
-            }
-            await (0, customEngineIpc_1.applyParsedRunnerEvent)(entry.emitter, frame).catch((err) => {
-                this.logger?.warn(`[RemoteEngine] emitter error: ${err instanceof Error ? err.message : String(err)}`);
-                return undefined;
-            });
-        }
-    }
-    failAll(err) {
-        for (const [id, entry] of this.pending) {
-            entry.reject(err);
-            this.pending.delete(id);
-        }
-    }
-    send(frame) {
-        this.channel.output.write((0, protocol_1.encodeClientFrame)(frame));
-    }
-}
-exports.RemoteEngine = RemoteEngine;

package/out/runtime/interfaces/config-provider.js

@@ -1,32 +0,0 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) AgentHippo.ai. All rights reserved.
- *--------------------------------------------------------------------------------------------*/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StaticConfigProvider = void 0;
-/**
- * Static configuration provider.
- * Suitable for CLI, testing, and production where config is passed explicitly.
- */
-class StaticConfigProvider {
-    config;
-    customProviders;
-    engineSettings;
-    constructor(config = {}, customProviders = {}, engineSettings = {}) {
-        this.config = config;
-        this.customProviders = customProviders;
-        this.engineSettings = engineSettings;
-    }
-    get(section, key, defaultValue) {
-        const fullKey = `${section}.${key}`;
-        const value = this.config[fullKey];
-        return (value !== undefined ? value : defaultValue);
-    }
-    getCustomProviders() {
-        return this.customProviders;
-    }
-    getEngineSettings() {
-        return this.engineSettings;
-    }
-}
-exports.StaticConfigProvider = StaticConfigProvider;

package/out/runtime/interfaces/edit-tracker.js

@@ -1,24 +0,0 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) AgentHippo.ai. All rights reserved.
- *--------------------------------------------------------------------------------------------*/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NoOpEditTracker = void 0;
-/**
- * No-op edit tracker.
- * Suitable for eval mode, CLI, and production where edit tracking is not needed.
- */
-class NoOpEditTracker {
-    /** Nothing is written back here — callers must not delete a file expecting this to restore it. */
-    appliesEdits = false;
-    async startTracking(_sessionId, _files) {
-        return undefined;
-    }
-    async stopTracking(_sessionId, _operationId) {
-        // No-op
-    }
-    async applyEdit(_sessionId, _filePath, _content, _isNewFile) {
-        // No-op
-    }
-}
-exports.NoOpEditTracker = NoOpEditTracker;

package/out/runtime/interfaces/index.js

@@ -1,29 +0,0 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) AgentHippo.ai. All rights reserved.
- *--------------------------------------------------------------------------------------------*/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StaticConfigProvider = exports.DirectorySessionStore = exports.FileSessionStore = exports.MemorySessionStore = exports.NoOpEditTracker = exports.CLIPermissionHandler = exports.AutoDenyPermissionHandler = exports.AutoApprovePermissionHandler = exports.NoOpLogger = exports.ConsoleLogger = void 0;
-/**
- * Runtime interfaces for AgentIDE engine abstraction.
- *
- * These interfaces abstract VS Code-specific dependencies to enable:
- * - Eval mode execution (fresh state, auto-approve)
- * - CLI/production server usage
- * - Testing without VS Code
- */
-var logger_1 = require("./logger");
-Object.defineProperty(exports, "ConsoleLogger", { enumerable: true, get: function () { return logger_1.ConsoleLogger; } });
-Object.defineProperty(exports, "NoOpLogger", { enumerable: true, get: function () { return logger_1.NoOpLogger; } });
-var permission_handler_1 = require("./permission-handler");
-Object.defineProperty(exports, "AutoApprovePermissionHandler", { enumerable: true, get: function () { return permission_handler_1.AutoApprovePermissionHandler; } });
-Object.defineProperty(exports, "AutoDenyPermissionHandler", { enumerable: true, get: function () { return permission_handler_1.AutoDenyPermissionHandler; } });
-Object.defineProperty(exports, "CLIPermissionHandler", { enumerable: true, get: function () { return permission_handler_1.CLIPermissionHandler; } });
-var edit_tracker_1 = require("./edit-tracker");
-Object.defineProperty(exports, "NoOpEditTracker", { enumerable: true, get: function () { return edit_tracker_1.NoOpEditTracker; } });
-var session_store_1 = require("./session-store");
-Object.defineProperty(exports, "MemorySessionStore", { enumerable: true, get: function () { return session_store_1.MemorySessionStore; } });
-Object.defineProperty(exports, "FileSessionStore", { enumerable: true, get: function () { return session_store_1.FileSessionStore; } });
-Object.defineProperty(exports, "DirectorySessionStore", { enumerable: true, get: function () { return session_store_1.DirectorySessionStore; } });
-var config_provider_1 = require("./config-provider");
-Object.defineProperty(exports, "StaticConfigProvider", { enumerable: true, get: function () { return config_provider_1.StaticConfigProvider; } });

package/out/runtime/interfaces/logger.js

@@ -1,40 +0,0 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) AgentHippo.ai. All rights reserved.
- *--------------------------------------------------------------------------------------------*/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NoOpLogger = exports.ConsoleLogger = void 0;
-/**
- * Console-based logger implementation.
- * Suitable for CLI, testing, and production server use.
- */
-class ConsoleLogger {
-    prefix;
-    constructor(prefix = '[AgentIDE]') {
-        this.prefix = prefix;
-    }
-    debug(message) {
-        console.debug(`${this.prefix} ${message}`);
-    }
-    info(message) {
-        console.log(`${this.prefix} ${message}`);
-    }
-    warn(message) {
-        console.warn(`${this.prefix} Warning: ${message}`);
-    }
-    error(message, error) {
-        console.error(`${this.prefix} Error: ${message}${error ? `: ${error.message}` : ''}`);
-    }
-}
-exports.ConsoleLogger = ConsoleLogger;
-/**
- * No-op logger for silent operation.
- * Useful for testing or when logging is not desired.
- */
-class NoOpLogger {
-    debug(_message) { }
-    info(_message) { }
-    warn(_message) { }
-    error(_message, _error) { }
-}
-exports.NoOpLogger = NoOpLogger;

package/out/runtime/interfaces/permission-handler.js

@@ -1,66 +0,0 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) AgentHippo.ai. All rights reserved.
- *--------------------------------------------------------------------------------------------*/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CLIPermissionHandler = exports.AutoDenyPermissionHandler = exports.AutoApprovePermissionHandler = void 0;
-/**
- * Auto-approve permission handler.
- * Approves all tool requests without prompting.
- * Suitable for eval mode, trusted automation, and unrestricted agents.
- */
-class AutoApprovePermissionHandler {
-    async requestPermission(_request) {
-        return { behavior: 'allow' };
-    }
-}
-exports.AutoApprovePermissionHandler = AutoApprovePermissionHandler;
-/**
- * Auto-deny permission handler.
- * Denies all tool requests.
- * Useful for read-only modes or security testing.
- */
-class AutoDenyPermissionHandler {
-    message;
-    constructor(message = 'All tool requests are denied') {
-        this.message = message;
-    }
-    async requestPermission(_request) {
-        return { behavior: 'deny', message: this.message };
-    }
-}
-exports.AutoDenyPermissionHandler = AutoDenyPermissionHandler;
-/**
- * CLI permission handler that prompts the user in the terminal.
- * Used when pack has approval: 'restricted'.
- */
-class CLIPermissionHandler {
-    readline;
-    async requestPermission(request) {
-        // Lazy load readline to avoid issues in non-CLI contexts
-        if (!this.readline) {
-            this.readline = require('readline');
-        }
-        return new Promise((resolve) => {
-            const rl = this.readline.createInterface({
-                input: process.stdin,
-                output: process.stdout,
-            });
-            const toolInfo = request.toolInput
-                ? `${request.toolName}: ${JSON.stringify(request.toolInput).slice(0, 100)}`
-                : request.toolName;
-            console.log(`\n⚠️  Tool permission requested: ${toolInfo}`);
-            rl.question('Allow? (y/n): ', (answer) => {
-                rl.close();
-                const allowed = answer.toLowerCase().startsWith('y');
-                if (allowed) {
-                    resolve({ behavior: 'allow' });
-                }
-                else {
-                    resolve({ behavior: 'deny', message: 'User denied permission' });
-                }
-            });
-        });
-    }
-}
-exports.CLIPermissionHandler = CLIPermissionHandler;