@agenthippo-ai/agenthippo 0.2.3-dataplane → 1.110.9

package/out/runner/protocol.js

@@ -0,0 +1,108 @@
+"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

@@ -0,0 +1,130 @@
+"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/edit-tracker.js

@@ -9,6 +9,8 @@ exports.NoOpEditTracker = void 0;
  * 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;
     }

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

@@ -44,6 +44,8 @@ const vscode = __importStar(require("vscode"));
  */
 class VSCodeEditTracker {
     logger;
+    /** `applyEdit` writes through the IDE's workspace edit, so a pre-delete is recoverable. */
+    appliesEdits = true;
     constructor(logger) {
         this.logger = logger;
     }