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

package/dist/adapters/openclaw/index.mjs

@@ -0,0 +1,240 @@
+import { Ct as finalTextEvent, H as CliProviderAdapterBase, Tt as sessionObservedEvents, V as recordCliTokenUsage, ot as prependPromptSection, x as nativeEffortArgs } from "../../src-Fn8Pu1xq.mjs";
+import { resolveTangleRouterDefaults } from "@tangle-network/agent-interface";
+//#region src/adapters/openclaw/adapter.ts
+/** openclaw's default agent id; the synthesized config declares only it. */
+const OPENCLAW_AGENT_ID = "main";
+/**
+* OpenClaw's embedded agent: `openclaw agent --local --json --agent main
+* --session-id <id> -m "<prompt>"`, configured by `~/.openclaw/openclaw.json`.
+* It does not stream: `--json` prints one envelope when the turn ends, and
+* that envelope is the only place it reports usage and its session id.
+*/
+var OpenclawProviderAdapter = class extends CliProviderAdapterBase {
+	provider = "openclaw";
+	profileHarness = "openclaw";
+	defaultCliPath = "openclaw";
+	/**
+	* Managed `~/.openclaw/openclaw.json` synthesized during initialize() and
+	* materialized to disk by the sidecar via getManagedAuthFiles(). Empty when
+	* the caller manages openclaw config itself.
+	*/
+	managedAuthFiles = [];
+	/**
+	* Openclaw reads NO credentials from env — it loads them from
+	* `~/.openclaw/openclaw.json`. A managed sandbox provisions none, so without
+	* a synthesized config openclaw falls back to its bundled `claude-cli`
+	* backend (which needs a Claude login) and the session never starts. Always
+	* synthesize a router-backed config so `openclaw agent --local` authenticates
+	* against the Tangle router, unless the caller manages config itself
+	* (authMode "config-only") or already supplied an `openclaw.json`.
+	*/
+	async afterInitialize(_config) {
+		this.managedAuthFiles = this.computeManagedAuthFiles();
+	}
+	getManagedAuthFiles() {
+		return this.managedAuthFiles;
+	}
+	computeManagedAuthFiles() {
+		if (this.config.authMode === "config-only") return [];
+		if ((this.config.authFiles ?? []).some((f) => f.path === ".openclaw/openclaw.json")) return [];
+		this.logger.debug("openclaw: synthesized managed router config");
+		return [{
+			path: ".openclaw/openclaw.json",
+			content: buildRouterOpenclawConfig(),
+			mode: 384
+		}];
+	}
+	buildExecArgs(params) {
+		const args = ["agent"];
+		args.push("--local");
+		args.push("--json");
+		args.push("--agent", OPENCLAW_AGENT_ID);
+		const nativeSessionId = params.sessionId ?? params.mintedSessionId;
+		if (nativeSessionId) args.push("--session-id", validateOpenclawSessionId(nativeSessionId));
+		args.push(...nativeEffortArgs("openclaw", params.config.profile?.model?.reasoningEffort));
+		if (params.config.extraFlags?.length) args.push(...params.config.extraFlags);
+		const fullMessage = prependPromptSection(params.systemPrompt, params.message);
+		args.push("-m", fullMessage);
+		return {
+			command: this.getCliPath(),
+			args,
+			useStdin: false
+		};
+	}
+	buildExecEnv(config) {
+		const env = this.agentEnvironmentValues();
+		env.OPENCLAW_NONINTERACTIVE = "1";
+		if (this.managedAuthFiles.length > 0) {
+			env.OPENAI_API_KEY = void 0;
+			env.ANTHROPIC_API_KEY = void 0;
+			env.OPENROUTER_API_KEY = void 0;
+			env.GEMINI_API_KEY = void 0;
+			env.GOOGLE_API_KEY = void 0;
+			const managedConfig = this.managedAuthFiles.find((f) => f.path.endsWith(".openclaw/openclaw.json"));
+			if (managedConfig && !env.OPENCLAW_CONFIG_PATH) env.OPENCLAW_CONFIG_PATH = `${(config.runtimeHome?.trim() || env.SIDECAR_AGENT_HOME?.trim() || env.AGENT_WORKSPACE_ROOT?.trim() || "/home/agent").replace(/\/+$/, "")}/${managedConfig.path}`;
+		}
+		return env;
+	}
+	/**
+	* openclaw's file and exec tools resolve against its agent workspace
+	* (`~/.openclaw/workspace` by default), not the process cwd, so a turn that
+	* did not pin it edited a directory the caller never sees.
+	*/
+	buildTurnEnvironment(executionConfig, profilePlan, workspaceRoot, correlationHeaders) {
+		return {
+			...super.buildTurnEnvironment(executionConfig, profilePlan, workspaceRoot, correlationHeaders),
+			OPENCLAW_WORKSPACE_DIR: workspaceRoot
+		};
+	}
+	createEventParser(state, onEvent) {
+		const ext = state;
+		ext.stdoutBuffer = "";
+		return {
+			parseAs: "raw",
+			onEvent: () => {},
+			onComplete: (rawBuffer) => {
+				ext.stdoutBuffer = rawBuffer ?? "";
+				for (const stream of this.flushEnvelope(ext)) onEvent?.(stream);
+			}
+		};
+	}
+	/**
+	* Parse the buffered stdout as openclaw's JSON envelope and synthesize the
+	* canonical message.part.updated + status:completed events.
+	*/
+	flushEnvelope(state) {
+		const trimmed = state.stdoutBuffer.trim();
+		if (!trimmed) return [];
+		let parsed;
+		try {
+			parsed = JSON.parse(trimmed);
+		} catch (err) {
+			return [{
+				type: "warning",
+				code: "OPENCLAW_PARSE_ERROR",
+				message: `Failed to parse openclaw envelope: ${err instanceof Error ? err.message : String(err)}`
+			}];
+		}
+		const text = extractFinalText(parsed);
+		const agentMeta = extractAgentMetadata(parsed);
+		const sessionId = typeof agentMeta.sessionId === "string" ? agentMeta.sessionId : void 0;
+		const events = sessionId ? sessionObservedEvents(state, "openclaw", sessionId) : [];
+		recordCliTokenUsage(state, agentMeta);
+		const textEvent = finalTextEvent(state, text);
+		if (text) events.push(textEvent);
+		events.push({
+			type: "raw",
+			backend: this.provider,
+			event: {
+				provider: agentMeta.provider,
+				model: agentMeta.model
+			}
+		});
+		events.push({
+			type: "status",
+			status: "completed"
+		});
+		return events;
+	}
+};
+/**
+* Walk an arbitrary content node and accumulate every string-valued `text`
+* field plus any direct strings. Bounded depth (default 4) prevents
+* runaway recursion on pathologically nested envelopes — OpenAI/Anthropic
+* shapes top out at ~2 levels of nesting in practice.
+*
+* Recognized shapes (real-world, from production CLIs that openclaw routes to):
+*   "plain string"
+*   { text: "..." }
+*   { type: "text", text: "..." }                    // OpenAI message content
+*   [{ type: "text", text: "..." }, ...]             // Anthropic blocks
+*   { content: ... }                                  // wrapper object
+*   { message: { content: ... } }                     // OpenAI choices.message
+*
+* Anything that doesn't match (numbers, booleans, tool-call descriptors)
+* is silently skipped — extracting *partial* text is better than throwing.
+*/
+function walkContentForText(raw, parts, depth = 4) {
+	if (depth <= 0 || raw == null) return;
+	if (typeof raw === "string") {
+		parts.push(raw);
+		return;
+	}
+	if (Array.isArray(raw)) {
+		for (const item of raw) walkContentForText(item, parts, depth - 1);
+		return;
+	}
+	if (typeof raw === "object") {
+		const obj = raw;
+		if (typeof obj.text === "string") {
+			parts.push(obj.text);
+			return;
+		}
+		if (obj.content !== void 0) {
+			walkContentForText(obj.content, parts, depth - 1);
+			return;
+		}
+		if (obj.message !== void 0) walkContentForText(obj.message, parts, depth - 1);
+	}
+}
+function extractFinalText(envelope) {
+	const payloads = envelope.payloads;
+	if (!Array.isArray(payloads)) return "";
+	const parts = [];
+	for (const payload of payloads) walkContentForText(payload, parts);
+	return parts.join("\n").trim();
+}
+/** Native agent --json metadata lives beside the reply payloads. */
+function extractAgentMetadata(envelope) {
+	const meta = envelope.meta;
+	if (!meta || typeof meta !== "object") return {};
+	const agentMeta = meta.agentMeta;
+	return agentMeta && typeof agentMeta === "object" ? agentMeta : {};
+}
+/**
+* Tight charset validator for openclaw session ids, which interpolate into
+* filesystem paths under ~/.openclaw/. Rejects traversal sequences, shell
+* metacharacters, whitespace and NULs. Allows lowercase alphanumerics, dash,
+* underscore and colon (session keys look like `agent:main:abc123`), capped
+* at 128 characters.
+*/
+function validateOpenclawSessionId(value) {
+	if (!/^[a-z0-9][a-z0-9_:-]{0,127}$/.test(value)) throw new Error(`openclaw: invalid session id ${JSON.stringify(value)} — must match /^[a-z0-9][a-z0-9_:-]{0,127}$/`);
+	return value;
+}
+/**
+* The `~/.openclaw/openclaw.json` that points openclaw's default agent at the
+* managed Tangle router, declared as the `openai-completions` provider
+* `tangle`. Its apiKey is an env template openclaw expands at load from the
+* salted per-sandbox key; the egress proxy swaps that for the real
+* budget-scoped key, so a managed session needs no per-sub-CLI credentials.
+* The shape follows openclaw's config schema: top-level `models`/`agents`,
+* and agent records carry a `model` ref.
+*/
+function buildRouterOpenclawConfig() {
+	const router = resolveTangleRouterDefaults();
+	const modelRef = `tangle/${router.model}`;
+	const config = {
+		models: { providers: { tangle: {
+			baseUrl: router.baseUrl,
+			apiKey: `\${${router.apiKeyEnvVar}}`,
+			api: "openai-completions",
+			models: [{
+				id: router.model,
+				name: router.model
+			}]
+		} } },
+		agents: {
+			defaults: {
+				model: { primary: modelRef },
+				skipBootstrap: true
+			},
+			entries: { [OPENCLAW_AGENT_ID]: { model: modelRef } }
+		}
+	};
+	return `${JSON.stringify(config, null, 2)}\n`;
+}
+//#endregion
+export { OpenclawProviderAdapter };
+
+//# sourceMappingURL=index.mjs.map

package/dist/adapters/prime/index.d.mts

@@ -0,0 +1,126 @@
+import { At as AcpTurn, Ct as AcpBridgeConfig, dn as AcpBridgeSpawn, fn as AcpProcessSpec, mt as AcpProviderAdapterBase, wt as AcpContentBlock } from "../../index-BpO3fvbf.mjs";
+import { i as PreparedAttachment } from "../../prompt-input-CD7okX8T.mjs";
+import { 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, PrimeMaterializeOptions, PrimeProfileControls, PrimeProfileControls as PrimeProfileControls$1, PrimeProfileError, PrimeProfileSkill, PrimeProfileSubagent, assertPrimeModelAgreement, hasPrimeProfileMaterial, matchPrimeKernelDeadMarker, materializePrimeProfileControls, primeAgentDirEnv, primeProfileNeedsAgentDir, primeSubagentEntryId as subagentEntryId, primeThinkingLevel, prunePrimeProfileMaterial, readPrimeProfileControls } from "@tangle-network/agent-profile-materialize";
+import { RpcBridge } from "@tangle-network/sdk-cli-runner";
+import { AgentExecutionInput, BackendCapabilities, ProviderConfig, StreamEvent } from "@tangle-network/agent-interface";
+import { MessagePart } from "@tangle-network/sdk-session-persistence";
+
+//#region src/adapters/prime/types.d.ts
+/**
+ * prime-agent settings. The ACP process settings (protocol version, prompt
+ * and bootstrap timeouts, idle reaping) come from {@link AcpBridgeConfig};
+ * prime's bootstrap can include first-run kernel venv provisioning, and a
+ * wedged kernel can leave a prompt silent until its timeout. The agent does
+ * not populate `rawOutput`: tool output arrives as tool-call content blocks.
+ */
+interface PrimeConfig extends AcpBridgeConfig {
+  /**
+   * Provider key written into the materialized `models.json` and passed as
+   * `--provider`. Purely a namespace inside the per-session agent dir.
+   * Default: "tangle".
+   */
+  modelProvider?: string;
+  /** Context window advertised for the materialized model entry. */
+  contextWindow?: number;
+  /** Max output tokens advertised for the materialized model entry. */
+  maxTokens?: number;
+  /** Whether the materialized model entry is reasoning-capable. */
+  reasoningModel?: boolean;
+  /**
+   * Share ONE prime agent dir (models.json, settings, sessions, and the
+   * self-modifying `harness/harness_state.json`) across every session of this
+   * adapter instance instead of the per-session default.
+   *
+   * prime-agent's harness state is persistent self-modification that rides
+   * every future system prompt — cross-session it is a prompt-injection
+   * channel, so isolation is the fail-closed default and this flag is the
+   * explicit opt-in for continual-mode experiments.
+   */
+  continualHarnessState?: boolean;
+}
+/**
+ * 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.
+ */
+declare class PrimeKernelDeadError extends Error {
+  readonly sessionId: string;
+  readonly marker: string;
+  readonly reason = "harness_exit";
+  constructor(sessionId: string, marker: string);
+}
+//#endregion
+//#region src/adapters/prime/adapter.d.ts
+/** Test seam — production always spawns via sdk-cli-runner's spawnRpcBridge. */
+declare function __setPrimeBridgeFactoryForTesting(factory: ((request: AcpBridgeSpawn) => RpcBridge) | null): void;
+/** A prime turn: the validated model tuple and the profile controls it runs. */
+interface PrimeTurn extends AcpTurn<PrimeConfig> {
+  readonly modelId: string;
+  readonly profileControls: PrimeProfileControls$1;
+}
+/**
+ * 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.
+ */
+declare class PrimeProviderAdapter extends AcpProviderAdapterBase<PrimeConfig, PrimeTurn> {
+  readonly provider = "prime";
+  protected readonly defaultCliPath = "prime-agent";
+  protected readonly loadsNativeSessions = false;
+  /** A dead kernel closes the ACP process and produces a typed turn failure. */
+  private readonly kernelDeaths;
+  protected resolveTurn(input: AgentExecutionInput): PrimeTurn;
+  protected processSpec(turn: PrimeTurn, context: {
+    sessionId: string;
+    workspaceRoot: string;
+  }): Promise<AcpProcessSpec>;
+  protected spawnFailureMessage(failure: {
+    message: string;
+    missingBinary: boolean;
+  }): string;
+  protected spawnBridge(request: AcpBridgeSpawn): RpcBridge;
+  /**
+   * 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.
+   */
+  protected onToolFailed(sessionId: string, failureText: string | undefined): StreamEvent[];
+  protected takeTurnFailure(sessionId: string): Error | undefined;
+  getCapabilities(): BackendCapabilities;
+  /** Prime accepts ACP image blocks, so images are forwarded natively. */
+  protected nativeAttachmentKinds(): ReadonlyArray<"image" | "file">;
+  protected afterInitialize(_config: ProviderConfig): Promise<void>;
+  /** Continual mode explicitly shares the native config and harness state. */
+  protected resolveAgentDir(config: PrimeConfig, sessionId: string): string;
+  private agentDirsRoot;
+  /** The dir every agent dir of this adapter is created below. */
+  private agentDirOwnerRoot;
+  protected buildSpawnEnv(agentDir: string): Record<string, string>;
+  protected buildSpawnArgs(config: PrimeConfig, modelId: string, profileArgs?: readonly string[]): string[];
+  private modelKey;
+  /**
+   * 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.
+   */
+  protected promptBlocks(input: AgentExecutionInput, preparedInput: {
+    promptText: string;
+    persistedParts: MessagePart[];
+    attachments: PreparedAttachment[];
+  }, turn: PrimeTurn): AcpContentBlock[];
+}
+//#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, type PrimeConfig, PrimeHarnessStateError, PrimeKernelDeadError, type PrimeMaterializeOptions, type PrimeProfileControls, PrimeProfileError, type PrimeProfileSkill, type PrimeProfileSubagent, PrimeProviderAdapter, __setPrimeBridgeFactoryForTesting, assertPrimeModelAgreement, hasPrimeProfileMaterial, matchPrimeKernelDeadMarker, materializePrimeProfileControls, primeAgentDirEnv, primeProfileNeedsAgentDir, primeThinkingLevel, prunePrimeProfileMaterial, readPrimeProfileControls, subagentEntryId };
+//# sourceMappingURL=index.d.mts.map