@tangle-network/sdk-provider-cli-base 0.13.17 → 0.13.19

package/dist/adapters/prime/index.mjs

@@ -0,0 +1,446 @@
+import { Ft as spawnAcpBridge, L as AcpProviderAdapterBase, ot as prependPromptSection } from "../../src-Fn8Pu1xq.mjs";
+import { PRIME_AGENT_DIR_ENV_VAR, PRIME_AGENT_DIR_ENV_VARS, PRIME_HARNESS_STATE_ENV_DENYLIST, PRIME_HARNESS_STATE_ENV_DENYLIST as PRIME_HARNESS_STATE_ENV_DENYLIST$1, PRIME_KERNEL_DEAD_MARKERS, PRIME_KERNEL_ENV_PASSTHROUGH, PRIME_KERNEL_ENV_PASSTHROUGH as PRIME_KERNEL_ENV_PASSTHROUGH$1, PRIME_MCP_UNSUPPORTED_REASON, PrimeHarnessStateError, PrimeProfileError, assertPrimeModelAgreement, assertPrimeModelAgreement as assertPrimeModelAgreement$1, buildPiModelsConfig, hasPrimeProfileMaterial, matchPrimeKernelDeadMarker, materializePrimeProfileControls, materializePrimeProfileControls as materializePrimeProfileControls$1, primeAgentDirEnv, primeAgentDirEnv as primeAgentDirEnv$1, primeHarnessStatePath, primeProfileNeedsAgentDir, primeSubagentEntryId as subagentEntryId, primeThinkingLevel, primeThinkingLevel as primeThinkingLevel$1, prunePrimeProfileMaterial, readPrimeProfileControls, readPrimeProfileControls as readPrimeProfileControls$1, writePrimeAgentFile } from "@tangle-network/agent-profile-materialize";
+import { isAbsolute, join, relative, sep } from "node:path";
+import { existsSync, lchownSync, lstatSync, mkdirSync } from "node:fs";
+import { z } from "zod";
+//#region src/adapters/prime/agent-dir.ts
+/**
+* File work inside a prime agent dir, run as the dir's owner. argv `read
+* <file>...` prints `{file: text | null}`; argv `write` reads
+* `[{path, data}]` from stdin and replaces each file whole through a private
+* temp name, so prime never reads a partial models.json.
+*/
+const AGENT_DIR_SCRIPT = `
+const fs = require("node:fs");
+const path = require("node:path");
+const crypto = require("node:crypto");
+const [mode, ...files] = process.argv.slice(1);
+if (mode === "read") {
+  const out = {};
+  for (const file of files) {
+    try {
+      out[file] = fs.readFileSync(file, "utf8");
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+      out[file] = null;
+    }
+  }
+  process.stdout.write(JSON.stringify(out));
+} else {
+  const chunks = [];
+  process.stdin.on("data", (chunk) => chunks.push(chunk));
+  process.stdin.on("end", () => {
+    for (const entry of JSON.parse(Buffer.concat(chunks).toString("utf8"))) {
+      fs.mkdirSync(path.dirname(entry.path), { recursive: true, mode: 0o700 });
+      const temp = entry.path + "." + crypto.randomUUID() + ".tmp";
+      try {
+        fs.writeFileSync(temp, entry.data, { encoding: "utf8", mode: 0o600, flag: "wx" });
+        fs.renameSync(temp, entry.path);
+      } finally {
+        fs.rmSync(temp, { force: true });
+      }
+    }
+  });
+}
+`;
+/**
+* Materialize a prime agent dir as the user prime-agent runs as.
+*
+* A root sidecar demotes prime-agent, so the agent dir and every file in it
+* must belong to that user: a root-owned models.json is unreadable to it, and
+* prime-agent exits before `initialize` with `Unknown provider "tangle"`.
+* Root only makes the per-session dir inside the adapter's own storage tree,
+* refusing a symlink anywhere below `storageRoot`, and hands the dir over
+* with lchown, which never follows a symlink. Every read and write inside it
+* runs through `runAsOwner` (the adapter's `runNodeAsSubprocess`), so a link
+* the agent plants there reaches only what the agent could already reach.
+*
+* `build` lowers the files through the port: `reads` are taken as the owner
+* first, and the writes it records are replayed as the owner after.
+*/
+async function materializeAgentDirAsOwner(options) {
+	const { storageRoot, agentDir, owner, reads, build } = options;
+	const runAsOwner = async (args, input) => {
+		try {
+			return await options.runAsOwner(AGENT_DIR_SCRIPT, args, input);
+		} catch (error) {
+			throw new Error(`prime: cannot ${args[0]} the agent dir as its owner: ${error instanceof Error ? error.message : String(error)}`);
+		}
+	};
+	const snapshot = ensureOwnedAgentDir(storageRoot, agentDir, owner) ? Object.fromEntries(reads.map((file) => [file, null])) : JSON.parse(await runAsOwner(["read", ...reads]));
+	const writes = [];
+	const result = build({
+		read: (file) => {
+			if (!Object.hasOwn(snapshot, file)) throw new Error(`prime: agent-dir read of ${file} was not taken`);
+			return snapshot[file] ?? void 0;
+		},
+		write: (file, data) => {
+			writes.push({
+				path: file,
+				data
+			});
+		}
+	});
+	if (writes.length > 0) await runAsOwner(["write"], JSON.stringify(writes));
+	return result;
+}
+/**
+* Make each missing dir from `storageRoot` down to `agentDir` and give the
+* leaf to `owner`; true when this call made the leaf. A symlink or a
+* non-directory on that path is refused, so root never creates or chowns
+* through a link the agent planted under its home.
+*/
+function ensureOwnedAgentDir(storageRoot, agentDir, owner) {
+	const below = relative(storageRoot, agentDir);
+	if (!below || below.startsWith("..") || isAbsolute(below)) throw new Error(`prime: agent dir ${agentDir} is outside ${storageRoot}`);
+	let dir = storageRoot;
+	let created = false;
+	for (const name of below.split(sep)) {
+		dir = join(dir, name);
+		created = true;
+		try {
+			mkdirSync(dir, dir === agentDir ? { mode: 448 } : void 0);
+		} catch (error) {
+			if (error.code !== "EEXIST") throw error;
+			created = false;
+		}
+		if (!lstatSync(dir).isDirectory()) throw new Error(`prime: agent dir path ${dir} is not a directory`);
+	}
+	if (owner) lchownSync(agentDir, owner.uid, owner.gid);
+	return created;
+}
+//#endregion
+//#region src/adapters/prime/models-config.ts
+/**
+* Materialization of prime-agent's `<agentDir>/models.json` from the
+* sandbox's model tuple.
+*
+* prime-agent resolves custom providers from `models.json` under its agent
+* config dir (fork `src/config.ts` `getAgentDir()` — overridable via
+* `PRIME_AGENT_CODING_AGENT_DIR`, which the adapter always sets). A custom
+* provider entry needs `baseUrl` + `api` + `apiKey` + at least one model id
+* (fork `docs/models.md`). `apiKey` accepts an env-var name, a `!shell`
+* command, or a literal; the sandbox writes the LITERAL key because inline
+* key injection is the established in-box router-auth pattern — the value is
+* the salted egress-proxy dummy, swapped for the real key at the network
+* boundary, so nothing secret lands on disk inside the box.
+*/
+/**
+* Write `models.json` into `agentDir`. The atomic temp+rename with an
+* owner-only mode is the shared agent-dir write: prime reloads this file at
+* model-resolution time, so a live process must never observe a partial write,
+* and the file names a credential either way (a literal here, an env var name
+* on the host path). `io` writes it as the agent dir's owner instead.
+*/
+function materializePrimeModelsConfig(agentDir, input, io = { write: writePrimeAgentFile }) {
+	const target = join(agentDir, "models.json");
+	io.write(target, `${JSON.stringify(buildPiModelsConfig(input), null, 2)}\n`);
+	return target;
+}
+//#endregion
+//#region src/adapters/prime/types.ts
+/**
+* Typed session-fatal error for a dead IPython kernel. Callers must treat the
+* session as unrecoverable and start a new one; the adapter has already
+* closed and evicted the backing prime-agent process when this throws.
+*/
+var PrimeKernelDeadError = class extends Error {
+	reason = "harness_exit";
+	constructor(sessionId, marker) {
+		super(`prime: IPython kernel died and prime-agent never re-provisions it headlessly (marker: "${marker}"). The session is unrecoverable; start a new session. (session ${sessionId})`);
+		this.sessionId = sessionId;
+		this.marker = marker;
+		this.name = "PrimeKernelDeadError";
+	}
+};
+//#endregion
+//#region src/adapters/prime/adapter.ts
+const DEFAULT_MODEL_PROVIDER = "tangle";
+/**
+* Env vars the adapter sets on the spawned prime-agent. The bridge lays this
+* env over the sidecar's inherited one (sdk-cli-runner mergeSpawnEnv), so the
+* runtime proxy and CA variables still reach prime; this list does not narrow
+* that. The model key travels via the materialized models.json, not env.
+*/
+const BASELINE_ENV_ALLOWLIST = [
+	"PATH",
+	"HOME",
+	"USER",
+	"LANG",
+	"LC_ALL",
+	"TZ",
+	"TMPDIR",
+	"TMP",
+	"TEMP",
+	"NODE_OPTIONS",
+	"NODE_PATH",
+	"NODE_NO_WARNINGS",
+	"NIX_BIN_PATH"
+];
+/**
+* Prime-specific operator knobs forwarded when present, and the env vars that
+* must never be forwarded — both fork facts, so both come from the shared
+* lowering. `PRIME_HARNESS_STATE_ENV_DENYLIST` names the vars that re-point the
+* self-modifying harness store OUTSIDE the per-session agent dir;
+* `config.continualHarnessState` is the one sanctioned escape hatch.
+*/
+const PRIME_ENV_PASSTHROUGH = PRIME_KERNEL_ENV_PASSTHROUGH$1;
+const primeProfileExtensionSchema = z.object({
+	modelProvider: z.string().min(1).optional(),
+	contextWindow: z.number().int().positive().optional(),
+	maxTokens: z.number().int().positive().optional(),
+	reasoningModel: z.boolean().optional(),
+	continualHarnessState: z.boolean().optional(),
+	promptTimeoutMs: z.number().int().positive().optional(),
+	bootstrapTimeoutMs: z.number().int().positive().optional(),
+	bridgeIdleMs: z.number().int().nonnegative().optional(),
+	protocolVersion: z.number().int().min(1).optional()
+}).strict();
+/**
+* Read `profile.extensions.prime` — the only part of the profile surface that
+* is adapter-specific rather than a fork fact. Every fork-level refusal (mcp,
+* connections, permissions, tools, hooks, modes, confidential, and the
+* resource kinds with no agent-dir read path) belongs to the shared lowering
+* and is raised by `readPrimeProfileControls`, so the two executors driving
+* this fork cannot drift on what it can honor.
+*
+* Honored profile surface: `model.default` falls back into the model id (and
+* must agree with it — `assertPrimeModelAgreement`), `model.reasoningEffort`
+* maps onto prime's `--thinking`, and `readPrimeProfileControls` closes
+* `harness: "prime"`, `prompt.systemPrompt`, `prompt.appendSystemPrompt`,
+* `prompt.instructions`, inline `resources.skills`, and `subagents` (see the
+* shared materializer's `src/prime-profile.ts` for each fork-verified path).
+*/
+function readPrimeProfileExtension(profile) {
+	if (!profile) return {};
+	const unsupportedExtensions = Object.entries(profile.extensions ?? {}).filter(([name, value]) => name !== "prime" && value !== void 0).map(([name]) => name);
+	if (unsupportedExtensions.length > 0) throw new Error(`prime does not support AgentProfile extension namespaces: ${unsupportedExtensions.join(", ")}`);
+	return primeProfileExtensionSchema.parse(profile.extensions?.prime ?? {});
+}
+let bridgeFactoryOverride = null;
+/** Test seam — production always spawns via sdk-cli-runner's spawnRpcBridge. */
+function __setPrimeBridgeFactoryForTesting(factory) {
+	bridgeFactoryOverride = factory;
+}
+/**
+* Prime Agent provider adapter.
+*
+* Spawns `prime-agent --mode acp` (JSON-RPC 2.0 over NDJSON on stdio — no
+* TUI; the fork internally routes the session through a client-owned daemon
+* worker that inherits this spawn's env, see types.ts). The ACP session
+* lifecycle is the shared {@link AcpProviderAdapterBase}; this adapter owns
+* prime's process, model tuple and failure signals.
+*
+* Each config directory owns its model tuple, daemon and harness state.
+* Kernel death closes the session with a typed failure.
+*
+* prime hosts one session per connection and has no `session/load`: a new
+* process opens a new ACP session, and the conversation resumes from prime's
+* own session files in the per-session agent dir.
+*/
+var PrimeProviderAdapter = class extends AcpProviderAdapterBase {
+	provider = "prime";
+	defaultCliPath = "prime-agent";
+	loadsNativeSessions = false;
+	/** A dead kernel closes the ACP process and produces a typed turn failure. */
+	kernelDeaths = /* @__PURE__ */ new Map();
+	resolveTurn(input) {
+		const profileExtension = readPrimeProfileExtension(this.config.profile);
+		const profileControls = readPrimeProfileControls$1(this.config.profile);
+		const config = {
+			...this.config,
+			...profileExtensionToConfig(profileExtension),
+			...input.model?.model ? { model: input.model.model } : {},
+			...input.model?.apiKey ? { apiKey: input.model.apiKey } : {},
+			...input.model?.baseUrl ? { baseUrl: input.model.baseUrl } : {}
+		};
+		const modelId = config.model ?? this.config.profile?.model?.default;
+		if (!modelId || !config.baseUrl || !config.apiKey) {
+			const missing = [
+				["model", modelId],
+				["baseUrl", config.baseUrl],
+				["apiKey", config.apiKey]
+			].filter(([, value]) => !value).map(([name]) => name);
+			throw new Error(`prime: a full model tuple is required (missing: ${missing.join(", ")}). The sandbox must deliver model + baseUrl + apiKey; prime-agent has no usable fallback inside an isolated agent dir and would exit at startup.`);
+		}
+		assertPrimeModelAgreement$1(this.config.profile, { model: modelId });
+		return {
+			config,
+			processKey: this.modelKey(config, modelId),
+			modelId,
+			profileControls
+		};
+	}
+	async processSpec(turn, context) {
+		const { config, modelId } = turn;
+		const agentDir = this.resolveAgentDir(config, context.sessionId);
+		const profileArgs = await materializeAgentDirAsOwner({
+			storageRoot: this.agentDirOwnerRoot(agentDir),
+			agentDir,
+			owner: this.subprocessIdentity(),
+			runAsOwner: (script, args, input) => this.runNodeAsSubprocess(script, args, input),
+			reads: [primeHarnessStatePath(agentDir)],
+			build: (io) => {
+				materializePrimeModelsConfig(agentDir, {
+					providerName: config.modelProvider ?? DEFAULT_MODEL_PROVIDER,
+					modelId,
+					baseUrl: config.baseUrl,
+					apiKey: config.apiKey,
+					contextWindow: config.contextWindow,
+					maxTokens: config.maxTokens,
+					reasoning: config.reasoningModel,
+					supportsStore: false
+				}, io);
+				return materializePrimeProfileControls$1(agentDir, turn.profileControls, {
+					warn: (msg, meta) => this.logger.warn(msg, meta),
+					io
+				});
+			}
+		});
+		const env = this.buildSpawnEnv(agentDir);
+		return {
+			command: this.getCliPath(),
+			args: [
+				...this.buildSpawnArgs(config, modelId, profileArgs),
+				"--daemon-socket",
+				env.PRIME_AGENT_DAEMON_SOCKET
+			],
+			env,
+			statusDetail: "Spawning prime-agent (ACP mode)"
+		};
+	}
+	spawnFailureMessage(failure) {
+		return failure.missingBinary ? `prime: "${this.getCliPath()}" not found on PATH. The container image must ship the pinned Prime native CLI and prepared Python kernel — see packages/sdk-provider-cli-base/docs/prime.md.` : `prime: failed to spawn prime-agent: ${failure.message}`;
+	}
+	spawnBridge(request) {
+		return (bridgeFactoryOverride ?? spawnAcpBridge)(request);
+	}
+	/**
+	* A failed tool whose output carries a kernel-death marker (the ipython
+	* tool, or a bootstrap diagnostic) ends the session: record it and close
+	* the process so the in-flight prompt can never hang on a dead kernel.
+	*/
+	onToolFailed(sessionId, failureText) {
+		const marker = failureText ? matchPrimeKernelDeadMarker(failureText) : void 0;
+		if (!marker || this.kernelDeaths.has(sessionId)) return [];
+		this.kernelDeaths.set(sessionId, marker);
+		this.logger.error("prime: IPython kernel died — failing session", {
+			sessionId,
+			marker
+		});
+		this.evictAcpSession(sessionId, "kernel-dead");
+		return [{
+			type: "warning",
+			code: "PRIME_KERNEL_DEAD",
+			message: `IPython kernel died ("${marker}") and prime-agent never re-provisions it headlessly. The session is unrecoverable.`
+		}];
+	}
+	takeTurnFailure(sessionId) {
+		const marker = this.kernelDeaths.get(sessionId);
+		if (!marker) return void 0;
+		this.kernelDeaths.delete(sessionId);
+		return new PrimeKernelDeadError(sessionId, marker);
+	}
+	getCapabilities() {
+		return {
+			streaming: true,
+			toolUse: true,
+			reasoning: true,
+			multimodal: true,
+			contextWindow: this.config.contextWindow ?? 128e3
+		};
+	}
+	/** Prime accepts ACP image blocks, so images are forwarded natively. */
+	nativeAttachmentKinds() {
+		return ["image"];
+	}
+	async afterInitialize(_config) {
+		readPrimeProfileExtension(this.config.profile);
+		readPrimeProfileControls$1(this.config.profile);
+	}
+	/** Continual mode explicitly shares the native config and harness state. */
+	resolveAgentDir(config, sessionId) {
+		const leaf = config.continualHarnessState ? "continual" : sessionId;
+		const workspaceDir = join(this.agentDirsRoot(this.storagePath), leaf);
+		const home = config.runtimeHome?.trim();
+		if (!home || existsSync(workspaceDir)) return workspaceDir;
+		return join(this.agentDirsRoot(home), leaf);
+	}
+	agentDirsRoot(base) {
+		return join(base, this.storageDir, "prime-agent-dirs");
+	}
+	/** The dir every agent dir of this adapter is created below. */
+	agentDirOwnerRoot(agentDir) {
+		const home = this.config.runtimeHome?.trim();
+		return home && agentDir.startsWith(`${this.agentDirsRoot(home)}/`) ? home : this.storagePath;
+	}
+	buildSpawnEnv(agentDir) {
+		const env = {};
+		for (const name of [...BASELINE_ENV_ALLOWLIST, ...PRIME_ENV_PASSTHROUGH]) {
+			const value = process.env[name];
+			if (value !== void 0) env[name] = value;
+		}
+		for (const name of PRIME_HARNESS_STATE_ENV_DENYLIST$1) delete env[name];
+		Object.assign(env, primeAgentDirEnv$1(agentDir));
+		return env;
+	}
+	buildSpawnArgs(config, modelId, profileArgs = []) {
+		const args = ["--mode", "acp"];
+		args.push("--provider", config.modelProvider ?? DEFAULT_MODEL_PROVIDER);
+		args.push("--model", modelId);
+		const thinking = primeThinkingLevel$1(this.config.profile?.model?.reasoningEffort);
+		if (thinking) args.push("--thinking", thinking);
+		args.push(...profileArgs);
+		if (config.extraFlags) args.push(...config.extraFlags);
+		return args;
+	}
+	modelKey(config, modelId) {
+		return [
+			config.modelProvider ?? DEFAULT_MODEL_PROVIDER,
+			modelId,
+			config.baseUrl ?? "",
+			config.apiKey ?? ""
+		].join("|");
+	}
+	/**
+	* ACP prompt blocks for a turn: the composed text plus every natively
+	* deliverable image. An image that could not be inlined (over budget,
+	* unreadable, remote-url) falls back to its text marker so the model still
+	* sees the reference instead of silently losing it.
+	*/
+	promptBlocks(input, preparedInput, turn) {
+		const imageBlocks = [];
+		const undeliverableMarkers = [];
+		for (const attachment of preparedInput.attachments) {
+			if (attachment.kind !== "image") continue;
+			if (attachment.base64 && attachment.mediaType) imageBlocks.push({
+				type: "image",
+				data: attachment.base64,
+				mimeType: attachment.mediaType
+			});
+			else undeliverableMarkers.push(attachment.marker);
+		}
+		const composed = prependPromptSection(input.systemPrompt === turn.profileControls.systemPrompt ? void 0 : input.systemPrompt, preparedInput.promptText);
+		return [{
+			type: "text",
+			text: undeliverableMarkers.length > 0 ? `${composed}\n\n${undeliverableMarkers.join("\n")}` : composed
+		}, ...imageBlocks];
+	}
+};
+function profileExtensionToConfig(extension) {
+	const out = {};
+	if (extension.modelProvider !== void 0) out.modelProvider = extension.modelProvider;
+	if (extension.contextWindow !== void 0) out.contextWindow = extension.contextWindow;
+	if (extension.maxTokens !== void 0) out.maxTokens = extension.maxTokens;
+	if (extension.reasoningModel !== void 0) out.reasoningModel = extension.reasoningModel;
+	if (extension.continualHarnessState !== void 0) out.continualHarnessState = extension.continualHarnessState;
+	if (extension.promptTimeoutMs !== void 0) out.promptTimeoutMs = extension.promptTimeoutMs;
+	if (extension.bootstrapTimeoutMs !== void 0) out.bootstrapTimeoutMs = extension.bootstrapTimeoutMs;
+	if (extension.bridgeIdleMs !== void 0) out.bridgeIdleMs = extension.bridgeIdleMs;
+	if (extension.protocolVersion !== void 0) out.protocolVersion = extension.protocolVersion;
+	return out;
+}
+//#endregion
+export { PRIME_AGENT_DIR_ENV_VAR, PRIME_AGENT_DIR_ENV_VARS, PRIME_HARNESS_STATE_ENV_DENYLIST, PRIME_KERNEL_DEAD_MARKERS, PRIME_KERNEL_ENV_PASSTHROUGH, PRIME_MCP_UNSUPPORTED_REASON, PrimeHarnessStateError, PrimeKernelDeadError, PrimeProfileError, PrimeProviderAdapter, __setPrimeBridgeFactoryForTesting, assertPrimeModelAgreement, hasPrimeProfileMaterial, matchPrimeKernelDeadMarker, materializePrimeProfileControls, primeAgentDirEnv, primeProfileNeedsAgentDir, primeThinkingLevel, prunePrimeProfileMaterial, readPrimeProfileControls, subagentEntryId };
+
+//# sourceMappingURL=index.mjs.map

package/dist/conformance/index.d.mts

@@ -1,4 +1,4 @@
-import { i as PreparedAttachment } from "../prompt-input-BHn_1z69.mjs";
+import { i as PreparedAttachment } from "../prompt-input-CD7okX8T.mjs";
 import { StreamEvent } from "@tangle-network/agent-interface";
 
 //#region src/conformance/attachments.d.ts