@agenthippo-ai/agenthippo 0.2.3-dataplane → 1.110.11

package/out/runner/protocol.js

@@ -0,0 +1,128 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTerminalFrame = isTerminalFrame;
+exports.isTaggedEvent = isTaggedEvent;
+exports.encodeRunnerFrame = encodeRunnerFrame;
+exports.encodeClientFrame = encodeClientFrame;
+exports.parseRunnerFrame = parseRunnerFrame;
+exports.parseClientFrame = parseClientFrame;
+exports.splitFrames = splitFrames;
+exports.toWireOptions = toWireOptions;
+function isTerminalFrame(frame) {
+    return 'type' in frame && (frame.type === 'result' || frame.type === 'failed');
+}
+/** A streamed event that names its turn — the only shape safe to route to a single emitter. */
+function isTaggedEvent(frame) {
+    return 'event' in frame;
+}
+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', ...(parsed.demux === true ? { demux: true } : {}) };
+    }
+    // Tagged streamed event. Checked before the untagged branch below because this envelope
+    // carries no top-level `type` — the inner event holds it. Validating that inner type here
+    // keeps a malformed envelope from becoming an event the emitter switch silently ignores,
+    // which would look like a turn that streamed nothing.
+    if (typeof parsed.id === 'string' && parsed.event && typeof parsed.event === 'object') {
+        const inner = parsed.event.type;
+        if (typeof inner === 'string' && RUNNER_EVENT_TYPES.has(inner)) {
+            return { id: parsed.id, event: parsed.event };
+        }
+        return undefined;
+    }
+    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,
+            ...(typeof parsed.id === 'string' ? { id: parsed.id } : {}),
+        };
+    }
+    // Untagged streamed event (legacy peer) — 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,166 @@
+"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;
+    /**
+     * Set from the peer's `ready` frame. Starts FALSE and stays false until the peer proves it
+     * tags streamed events: a run frame can be sent before `ready` arrives, so "not yet known"
+     * must mean "assume it cannot", or the first pair of concurrent turns races the handshake.
+     */
+    peerDemux = 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, chain: Promise.resolve() });
+        });
+        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;
+                }
+                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))));
+    }
+    dispatch(frame) {
+        if ((0, protocol_1.isTaggedEvent)(frame)) {
+            // Routed to exactly one turn. No entry means the turn already settled or was aborted
+            // and a late event arrived behind its terminal frame — dropping it is correct.
+            this.enqueue(this.pending.get(frame.id), (e) => (0, customEngineIpc_1.applyParsedRunnerEvent)(e.emitter, frame.event));
+            return;
+        }
+        if (frame.type === 'ready') {
+            this.peerDemux = frame.demux === true;
+            return;
+        }
+        if (frame.type === 'result') {
+            // Behind this turn's own events, so a turn never settles while its last delta is still
+            // inside an unfinished emitter call.
+            this.settle(frame.id, (entry) => entry.resolve(frame.nativeSessionId));
+            return;
+        }
+        if (frame.type === 'failed') {
+            this.settle(frame.id, (entry) => entry.reject(new Error(frame.message)));
+            return;
+        }
+        if (frame.type === 'question') {
+            // One-way notification; the runner already answered it `declined` locally.
+            const targets = frame.id ? [this.pending.get(frame.id)] : [...this.pending.values()];
+            for (const entry of targets) {
+                this.enqueue(entry, (e) => e.emitter.question(frame.payload).then(() => undefined));
+            }
+            return;
+        }
+        // LEGACY peer only: untagged events carry nothing that names their turn, so the best
+        // available behaviour is to broadcast. That is only safe because a peer which has not
+        // advertised `demux` is given one turn at a time (see sandboxRunner's `exclusive`).
+        for (const entry of this.pending.values()) {
+            this.enqueue(entry, (e) => (0, customEngineIpc_1.applyParsedRunnerEvent)(e.emitter, frame).then(() => undefined));
+        }
+    }
+    /** Appends work to one turn's ordered chain. An emitter failure never breaks the chain. */
+    enqueue(entry, work) {
+        if (!entry) {
+            return;
+        }
+        entry.chain = entry.chain.then(() => work(entry)).then(() => undefined, (err) => {
+            this.logger?.warn(`[RemoteEngine] emitter error: ${err instanceof Error ? err.message : String(err)}`);
+        });
+    }
+    /** Settles a turn once everything already streamed for it has been applied. */
+    settle(id, finish) {
+        const entry = this.pending.get(id);
+        if (!entry) {
+            return;
+        }
+        void entry.chain.then(() => finish(entry));
+    }
+    /** True once the peer's `ready` proved it tags streamed events — see `peerDemux`. */
+    supportsDemux() {
+        return this.peerDemux;
+    }
+    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;
     }