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

package/dist/adapters/hermes/index.mjs

@@ -0,0 +1,244 @@
+import { G as isLocalMcpConfig, H as CliProviderAdapterBase, I as plaintextResponseParser, K as localMcpArgv, Tt as sessionObservedEvents, V as recordCliTokenUsage, it as partitionImageAttachments, ot as prependPromptSection, q as localMcpEnv } from "../../src-Fn8Pu1xq.mjs";
+import { resolveTangleRouterDefaults } from "@tangle-network/agent-interface";
+import { lchown, mkdir, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+//#region src/adapters/hermes/adapter.ts
+/** Hermes provider name to the env var that holds its API key. */
+const PROVIDER_API_KEY_ENV = {
+	auto: "OPENROUTER_API_KEY",
+	openrouter: "OPENROUTER_API_KEY",
+	anthropic: "ANTHROPIC_API_KEY",
+	"openai-codex": "OPENAI_API_KEY",
+	nous: "NOUS_API_KEY",
+	custom: "OPENAI_API_KEY"
+};
+/**
+* Maps a hermes inference provider to the env var hermes consults for the
+* provider base URL. Used to point hermes at tangle-router or a self-hosted
+* OpenAI-compatible endpoint without writing config files at runtime.
+*/
+const PROVIDER_BASE_URL_ENV = {
+	auto: null,
+	openrouter: "OPENROUTER_BASE_URL",
+	anthropic: "ANTHROPIC_BASE_URL",
+	"openai-codex": "OPENAI_BASE_URL",
+	nous: null,
+	custom: "OPENAI_BASE_URL"
+};
+var HermesProviderAdapter = class extends CliProviderAdapterBase {
+	provider = "hermes";
+	profileHarness = "hermes";
+	activeSessionId;
+	defaultCliPath = "hermes";
+	isBenignNonZeroExit({ exitCode, stderr, state }) {
+		if (exitCode === null || exitCode === 0) return false;
+		if (state.textBuffer.trim().length > 0) return true;
+		return /session_id:\s*\S/.test(stderr);
+	}
+	buildMcpAddArgs(name, config) {
+		const args = [
+			"mcp",
+			"add",
+			name
+		];
+		if (!isLocalMcpConfig(config)) return [
+			...args,
+			"--url",
+			config.url
+		];
+		const [command, ...commandArgs] = localMcpArgv(config);
+		args.push("--command", command);
+		if (commandArgs.length > 0) args.push("--args", ...commandArgs);
+		const environment = localMcpEnv(config);
+		if (environment && Object.keys(environment).length > 0) args.push("--env", ...Object.entries(environment).map(([key, value]) => `${key}=${value}`));
+		return args;
+	}
+	/** The contract store, or a workspace fallback when no runtime home is set. */
+	resolveHermesHome() {
+		const runtimeHome = this.config.runtimeHome?.trim();
+		if (runtimeHome) return join(runtimeHome, ".hermes");
+		if (!this.activeSessionId) throw new Error("Hermes native session id is required before resolving HERMES_HOME");
+		return join(process.env.AGENT_WORKSPACE_ROOT?.trim() || this.storagePath, ".hermes", "sessions", this.activeSessionId);
+	}
+	async preparePromptInput(parts, workspaceRoot, sessionId) {
+		if (!/^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/.test(sessionId)) throw new Error("Hermes native session id is not a safe directory name");
+		if (this.activeSessionId && this.activeSessionId !== sessionId) throw new Error("Hermes backend cannot serve two native sessions");
+		this.activeSessionId = sessionId;
+		const home = this.resolveHermesHome();
+		const created = await mkdir(home, { recursive: true });
+		await writeFile(join(home, "config.yaml"), "agent:\n  auto_recovery_cycles: 0\n", { flag: "wx" }).catch(() => void 0);
+		const owner = this.subprocessIdentity();
+		if (owner) {
+			const sessions = dirname(home);
+			const top = created !== void 0 && sessions.startsWith(`${created}/`) ? created : sessions;
+			for (let dir = home;; dir = dirname(dir)) {
+				await lchown(dir, owner.uid, owner.gid);
+				if (dir === top) break;
+			}
+		}
+		return super.preparePromptInput(parts, workspaceRoot, sessionId, { inlineImageBudgetBytes: 0 });
+	}
+	nativeAttachmentKinds() {
+		return ["image"];
+	}
+	buildExecArgs(params) {
+		const args = ["chat", "--quiet"];
+		const gatewayDefaults = resolveTangleRouterDefaults();
+		const configuredProvider = params.config.inferenceProvider;
+		const defaultThroughGateway = !configuredProvider || configuredProvider === "openrouter" || configuredProvider === "custom" || configuredProvider === "openai-codex";
+		const model = params.model ?? params.config.model ?? (defaultThroughGateway ? gatewayDefaults.model : void 0);
+		if (model) {
+			args.push("--model", model);
+			const provider = configuredProvider ?? "openrouter";
+			if (provider) args.push("--provider", provider);
+		}
+		if (params.config.toolsets?.length) args.push("--toolsets", params.config.toolsets.join(","));
+		if (params.sessionId) {
+			this.releaseTurnLease(params.sessionId);
+			args.push("--resume", params.sessionId);
+		}
+		if (params.config.bypassPermissions !== false) args.push("--yolo");
+		if (params.config.extraFlags?.length) args.push(...params.config.extraFlags);
+		const { native: nativeImages, message: messageWithStrandedMarkers } = partitionImageAttachments({
+			message: params.message,
+			attachments: params.attachments,
+			qualifies: (attachment) => attachment.path !== void 0,
+			maxNative: 1
+		});
+		const nativePath = nativeImages[0]?.path;
+		const fullMessage = prependPromptSection(params.systemPrompt, messageWithStrandedMarkers);
+		if (nativePath) args.push("--image", nativePath);
+		args.push("-q", fullMessage);
+		return {
+			command: this.getCliPath(),
+			args,
+			useStdin: false
+		};
+	}
+	releaseTurnLease(sessionId) {
+		const home = this.config.runtimeHome?.trim();
+		if (!home) return;
+		try {
+			const db = new DatabaseSync(join(home, ".hermes", "state.db"), { timeout: 2e3 });
+			try {
+				db.prepare("DELETE FROM session_turn_leases WHERE conversation_id = ?").run(sessionId);
+			} finally {
+				db.close();
+			}
+		} catch {
+			return;
+		}
+	}
+	buildExecEnv(config) {
+		const env = this.agentEnvironmentValues();
+		env.HERMES_HOME = this.resolveHermesHome();
+		const authMode = config.authMode ?? (config.apiKey ? "api-key" : "oauth");
+		const gatewayDefaults = resolveTangleRouterDefaults();
+		const configuredProvider = config.inferenceProvider;
+		const provider = configuredProvider ?? "openrouter";
+		const defaultThroughGateway = !configuredProvider || configuredProvider === "openrouter" || configuredProvider === "custom" || configuredProvider === "openai-codex";
+		if (authMode === "api-key" && config.apiKey) {
+			const keyEnv = PROVIDER_API_KEY_ENV[provider];
+			if (keyEnv) env[keyEnv] = config.apiKey;
+		}
+		const baseUrl = config.baseUrl || (defaultThroughGateway ? gatewayDefaults.baseUrl : void 0);
+		if (baseUrl) {
+			const urlEnv = PROVIDER_BASE_URL_ENV[provider];
+			if (urlEnv) env[urlEnv] = baseUrl;
+		}
+		const model = config.model ?? (defaultThroughGateway ? gatewayDefaults.model : void 0);
+		if (model) env.HERMES_INFERENCE_MODEL = model;
+		return env;
+	}
+	async afterCliProcessExit(params) {
+		const hermesSessionId = parseHermesSessionId(params.stderr);
+		if (!hermesSessionId) return;
+		for (const event of sessionObservedEvents(params.state, "hermes", hermesSessionId)) params.onEvent?.(event);
+		if (!params.exit.success) return;
+		const exported = await this.runCli({
+			command: this.getCliPath(),
+			args: [
+				"sessions",
+				"export",
+				"--session-id",
+				hermesSessionId,
+				"-"
+			],
+			cwd: params.workspaceRoot,
+			env: params.env,
+			timeoutMs: 15e3
+		});
+		if (!exported.exit.success) {
+			this.logger.warn("hermes: session export failed after run", {
+				sessionId: hermesSessionId,
+				exitCode: exported.exit.code,
+				stderr: exported.stderr.slice(0, 500)
+			});
+			return;
+		}
+		let session;
+		try {
+			session = parseHermesExport(exported.stdout ?? "");
+		} catch (error) {
+			this.logger.warn("hermes: session export returned invalid JSON", {
+				sessionId: hermesSessionId,
+				error: error instanceof Error ? error.message : String(error)
+			});
+			return;
+		}
+		if (!session) {
+			this.logger.warn("hermes: session export did not return JSON", { sessionId: hermesSessionId });
+			return;
+		}
+		recordCliTokenUsage(params.state, {
+			usage: {
+				input_tokens: session.input_tokens,
+				output_tokens: session.output_tokens,
+				cache_read_input_tokens: session.cache_read_tokens,
+				cache_creation_input_tokens: session.cache_write_tokens
+			},
+			cost_usd: session.actual_cost_usd ?? session.estimated_cost_usd
+		});
+	}
+	createEventParser(state, onEvent) {
+		return plaintextResponseParser(state, onEvent, {
+			classify: (line) => line.startsWith("API call failed") || line.startsWith("Error:") || line.startsWith("hermes:") ? {
+				type: "error",
+				message: line
+			} : {
+				type: "text",
+				line
+			},
+			map: (event, response) => {
+				switch (event.type) {
+					case "text":
+						response.text(event.line);
+						return [];
+					case "error":
+						response.error(event.message);
+						return [{
+							type: "warning",
+							code: "HERMES_ERROR",
+							message: event.message
+						}];
+					case "complete": return [];
+				}
+			},
+			emptyFailureDetail: "hermes errored without producing a response body"
+		});
+	}
+};
+function parseHermesSessionId(stderr) {
+	return /(?:^|\n)\s*session_id:\s*([^\s]+)/i.exec(stderr)?.[1];
+}
+function parseHermesExport(stdout) {
+	const line = stdout.split(/\r?\n/).map((entry) => entry.trim()).find(Boolean);
+	if (!line) return void 0;
+	const parsed = JSON.parse(line);
+	return typeof parsed === "object" && parsed !== null ? parsed : void 0;
+}
+//#endregion
+export { HermesProviderAdapter };
+
+//# sourceMappingURL=index.mjs.map

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

@@ -0,0 +1,50 @@
+import { Mt as CliExecArgs, Pt as CliProviderConfig, Rt as ExecutionState, ht as CliProviderAdapterBase, n as HarnessId } from "../../index-BpO3fvbf.mjs";
+import { StreamParserConfig } from "@tangle-network/sdk-cli-runner";
+import { StreamEvent } from "@tangle-network/agent-interface";
+
+//#region src/adapters/nanoclaw/types.d.ts
+type NanoclawAuthMode = "api-key" | "oauth";
+interface NanoclawConfig extends CliProviderConfig {
+  projectRoot?: string;
+  apiKey?: string;
+  authMode?: NanoclawAuthMode;
+  baseUrl?: string;
+}
+interface NanoclawTextEvent {
+  type: "text";
+  line: string;
+}
+interface NanoclawErrorEvent {
+  type: "error";
+  message: string;
+}
+interface NanoclawUsageEvent {
+  type: "usage";
+  usage: Record<string, unknown>;
+  raw: string;
+}
+interface NanoclawSessionEvent {
+  type: "session";
+  id: string;
+}
+type NanoclawEvent = NanoclawTextEvent | NanoclawErrorEvent | NanoclawUsageEvent | NanoclawSessionEvent;
+//#endregion
+//#region src/adapters/nanoclaw/adapter.d.ts
+declare class NanoclawProviderAdapter extends CliProviderAdapterBase<NanoclawConfig, NanoclawEvent> {
+  readonly provider = "nanoclaw";
+  protected readonly profileHarness: HarnessId;
+  protected readonly defaultCliPath = "tsx";
+  protected buildExecArgs(params: {
+    message: string;
+    config: NanoclawConfig;
+    model?: string;
+    sessionId?: string;
+    workspaceRoot: string;
+    systemPrompt?: string;
+  }): CliExecArgs;
+  protected buildExecEnv(config: NanoclawConfig): Record<string, string | undefined>;
+  protected createEventParser(state: ExecutionState, onEvent?: (event: StreamEvent) => void): StreamParserConfig<NanoclawEvent>;
+}
+//#endregion
+export { type NanoclawConfig, type NanoclawEvent, NanoclawProviderAdapter };
+//# sourceMappingURL=index.d.mts.map

package/dist/adapters/nanoclaw/index.mjs

@@ -0,0 +1,116 @@
+import { H as CliProviderAdapterBase, I as plaintextResponseParser, Tt as sessionObservedEvents, V as recordCliTokenUsage, ot as prependPromptSection, z as parseCliUsageLine } from "../../src-Fn8Pu1xq.mjs";
+import { normalizeOpenAiCompatibleBaseUrl, resolveTangleRouterDefaults } from "@tangle-network/agent-interface";
+import { join } from "node:path";
+//#region src/adapters/nanoclaw/adapter.ts
+var NanoclawProviderAdapter = class extends CliProviderAdapterBase {
+	provider = "nanoclaw";
+	profileHarness = "nanoclaw";
+	defaultCliPath = "tsx";
+	buildExecArgs(params) {
+		const projectRoot = params.config.projectRoot ?? process.env.NANOCLAW_PROJECT_ROOT ?? params.workspaceRoot;
+		const fullMessage = prependPromptSection(params.systemPrompt, params.message);
+		return {
+			command: join(projectRoot, "node_modules", ".bin", "tsx"),
+			args: [
+				join(projectRoot, "scripts", "chat.ts"),
+				"nanoclaw-chat",
+				params.sessionId ?? "-",
+				fullMessage
+			],
+			cwd: projectRoot,
+			useStdin: false
+		};
+	}
+	buildExecEnv(config) {
+		const env = this.agentEnvironmentValues();
+		if (config.projectRoot) env.NANOCLAW_PROJECT_ROOT = config.projectRoot;
+		env.NANOCLAW_NATIVE_CREDENTIALS ??= "true";
+		env.COREPACK_ENABLE_DOWNLOAD_PROMPT = "0";
+		const modelKey = config.apiKey ?? env.OPENCODE_MODEL_API_KEY;
+		const authMode = config.authMode ?? (modelKey ? "api-key" : "oauth");
+		if (authMode === "api-key" && modelKey) {
+			env.OPENCODE_MODEL_API_KEY = modelKey;
+			env.OPENAI_API_KEY = modelKey;
+			env.OPENROUTER_API_KEY = modelKey;
+			env.ANTHROPIC_AUTH_TOKEN = modelKey;
+		} else if (authMode !== "api-key") {
+			env.OPENCODE_MODEL_API_KEY = void 0;
+			env.OPENAI_API_KEY = void 0;
+			env.OPENROUTER_API_KEY = void 0;
+			env.ANTHROPIC_AUTH_TOKEN = void 0;
+		}
+		const gatewayDefaults = resolveTangleRouterDefaults(env);
+		const openAiBaseUrl = config.baseUrl ? normalizeOpenAiCompatibleBaseUrl(config.baseUrl) : gatewayDefaults.baseUrl;
+		env.OPENAI_BASE_URL ??= openAiBaseUrl;
+		env.OPENROUTER_BASE_URL ??= openAiBaseUrl;
+		env.ANTHROPIC_BASE_URL ??= resolveAnthropicBaseUrl(config.baseUrl ?? gatewayDefaults.rootUrl);
+		const model = config.model ?? gatewayDefaults.model;
+		if (model) env.TANGLE_ROUTER_MODEL = model;
+		return env;
+	}
+	createEventParser(state, onEvent) {
+		return plaintextResponseParser(state, onEvent, {
+			classify: classifyNanoclawLine,
+			map: (event, response) => {
+				switch (event.type) {
+					case "text":
+						response.text(event.line);
+						return [];
+					case "session":
+						if (state.sessionId === event.id) return [];
+						return sessionObservedEvents(state, "nanoclaw", event.id);
+					case "error":
+						response.error(event.message);
+						return [{
+							type: "warning",
+							code: "NANOCLAW_ERROR",
+							message: event.message
+						}];
+					case "usage":
+						recordCliTokenUsage(state, event.usage);
+						return [];
+				}
+			},
+			emptyFailureDetail: "nanoclaw exited without producing a response body"
+		});
+	}
+};
+function classifyNanoclawLine(line) {
+	if (line.length === 0) return null;
+	if (line.startsWith("nanoclaw-session:")) {
+		const id = line.slice(17).trim();
+		return id ? {
+			type: "session",
+			id
+		} : null;
+	}
+	if (line.startsWith("usage:")) {
+		try {
+			const usage = parseCliUsageLine(line);
+			if (usage) return {
+				type: "usage",
+				usage,
+				raw: line
+			};
+		} catch {}
+		return {
+			type: "error",
+			message: `Unparseable NanoClaw usage line: ${line}`
+		};
+	}
+	if (line.startsWith("NanoClaw daemon not reachable") || line.startsWith("CLI socket error:") || line.startsWith("timeout:")) return {
+		type: "error",
+		message: line
+	};
+	return {
+		type: "text",
+		line
+	};
+}
+function resolveAnthropicBaseUrl(baseUrl) {
+	return baseUrl.replace(/\/+$/, "").replace(/\/v\d+[^/]*$/, "");
+}
+//#endregion
+export { NanoclawProviderAdapter };
+
+//# sourceMappingURL=index.mjs.map

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

@@ -0,0 +1,68 @@
+import { Mt as CliExecArgs, Pt as CliProviderConfig, Rt as ExecutionState, ht as CliProviderAdapterBase, n as HarnessId, o as WorkspacePlanApplication } from "../../index-BpO3fvbf.mjs";
+import { StreamParserConfig } from "@tangle-network/sdk-cli-runner";
+import { CliAuthFile, ProviderConfig, StreamEvent } from "@tangle-network/agent-interface";
+
+//#region src/adapters/openclaw/adapter.d.ts
+/**
+ * OpenClaw configuration. `authMode` "config-only" means openclaw uses the
+ * config already in $HOME (a workspace restored from a snapshot); otherwise
+ * the adapter synthesizes a router-backed `~/.openclaw/openclaw.json` unless
+ * `authFiles` already carries one.
+ */
+interface OpenclawConfig extends CliProviderConfig {
+  authMode?: "auth-files" | "config-only";
+}
+/**
+ * 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.
+ */
+declare class OpenclawProviderAdapter extends CliProviderAdapterBase<OpenclawConfig, never> {
+  readonly provider = "openclaw";
+  protected readonly profileHarness: HarnessId;
+  protected readonly 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.
+   */
+  private 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`.
+   */
+  protected afterInitialize(_config: ProviderConfig): Promise<void>;
+  getManagedAuthFiles(): CliAuthFile[];
+  private computeManagedAuthFiles;
+  protected buildExecArgs(params: {
+    message: string;
+    config: OpenclawConfig;
+    model?: string;
+    sessionId?: string;
+    mintedSessionId?: string;
+    workspaceRoot: string;
+    systemPrompt?: string;
+  }): CliExecArgs;
+  protected buildExecEnv(config: OpenclawConfig): Record<string, string | undefined>;
+  /**
+   * 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.
+   */
+  protected buildTurnEnvironment(executionConfig: OpenclawConfig, profilePlan: WorkspacePlanApplication | undefined, workspaceRoot: string, correlationHeaders: Readonly<Record<string, string>> | undefined): Record<string, string | undefined>;
+  protected createEventParser(state: ExecutionState, onEvent?: (event: StreamEvent) => void): StreamParserConfig<never>;
+  /**
+   * Parse the buffered stdout as openclaw's JSON envelope and synthesize the
+   * canonical message.part.updated + status:completed events.
+   */
+  private flushEnvelope;
+}
+//#endregion
+export { OpenclawProviderAdapter };
+//# sourceMappingURL=index.d.mts.map