@tangle-network/sdk-provider-cli-base 0.13.16 → 0.13.18

package/dist/adapters/factory-droids/index.mjs

@@ -0,0 +1,356 @@
+import { At as toolStartEvents, Dt as textDeltaEvents, Et as streamPartBase, F as jsonEventParser, G as isLocalMcpConfig, H as CliProviderAdapterBase, J as enabledInteractionKinds, K as localMcpArgv, Tt as sessionObservedEvents, V as recordCliTokenUsage, et as withTurnInteractions, k as McpInteractionSupport, kt as toolResultEvents, q as localMcpEnv, wt as reasoningEvents } from "../../src-Fn8Pu1xq.mjs";
+import { createHash, randomUUID } from "node:crypto";
+import { InteractionKind } from "@tangle-network/agent-interface";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { renameSync, rmSync, writeFileSync } from "node:fs";
+//#region src/adapters/factory-droids/event-mapper.ts
+/**
+* Type guard for Factory Droids events.
+*/
+function isFactoryDroidsEvent(value) {
+	if (typeof value !== "object" || value === null) return false;
+	return typeof value.type === "string";
+}
+function mapToolResultEvent(event, state) {
+	return toolResultEvents(state, {
+		id: event.tool_use_id,
+		content: event.content,
+		isError: Boolean(event.is_error)
+	});
+}
+/**
+* Maps a Factory Droids system event to StreamEvents.
+*/
+function mapSystemEvent(event) {
+	return [{
+		type: "status",
+		status: "processing",
+		detail: event.content
+	}];
+}
+/**
+* Maps a Factory Droids error event to a failed terminal status carrying
+* droid's own message. droid exits 0 after an error event, so a warning left
+* the turn as "completed without user-visible output" and lost the cause.
+*/
+function mapErrorEvent(event) {
+	return [{
+		type: "status",
+		status: "failed",
+		detail: event.message ?? event.content ?? `Factory Droids error ${event.code ?? "FACTORY_DROIDS_ERROR"}`
+	}];
+}
+/**
+* Maps a Factory Droids result event to StreamEvents.
+*/
+function mapResultEvent(event, state) {
+	recordCliTokenUsage(state, event);
+	return [{
+		type: "status",
+		status: "completed"
+	}];
+}
+/**
+* droid ≥0.159 `message` event — assistant text accumulates into the buffer
+* exactly like the older `assistant` event (each event is a full turn, so turns
+* are newline-joined); the `user` echo of our own prompt is ignored.
+*/
+function mapMessageEvent(event, state) {
+	if (event.role !== "assistant" || !event.text) return [];
+	const previousLength = state.textBuffer.length;
+	state.textBuffer += previousLength > 0 ? `\n${event.text}` : event.text;
+	state.textPartId ??= randomUUID();
+	const textPart = {
+		...streamPartBase(state, state.textPartId),
+		type: "text",
+		text: state.textBuffer
+	};
+	const events = [];
+	if (previousLength === 0) events.push({
+		type: "model-processing",
+		phase: "generating"
+	});
+	events.push({
+		type: "message.part.updated",
+		part: textPart
+	});
+	return events;
+}
+/** droid ≥0.159 `tool_call` event — same role as the older `tool_use`. */
+function mapToolCallEvent(event, state) {
+	return toolStartEvents(state, {
+		id: event.toolId ?? event.id ?? randomUUID(),
+		name: event.toolName,
+		input: event.parameters ?? {}
+	});
+}
+/** droid ≥0.159 terminal `completion` event — same role as the older `result`. */
+function mapCompletionEvent(event, state) {
+	const events = [];
+	if (state.textBuffer.length === 0 && event.finalText) {
+		state.textBuffer = event.finalText;
+		state.textPartId ??= randomUUID();
+		events.push({
+			type: "message.part.updated",
+			part: {
+				...streamPartBase(state, state.textPartId),
+				type: "text",
+				text: state.textBuffer
+			}
+		});
+	}
+	return [...events, ...mapResultEvent({
+		type: "result",
+		text: event.finalText ?? "",
+		session_id: event.session_id,
+		usage: event.usage
+	}, state)];
+}
+/**
+* Maps a Factory Droids event to StreamEvent(s).
+*
+* Uses message.part.updated as the primary event type for all content updates,
+* matching the OpenCode provider's event format.
+*
+* @param event - The Factory Droids event
+* @param state - The execution state (mutated by this function)
+* @returns Array of StreamEvents
+*/
+function mapFactoryDroidsEvent(event, state) {
+	return [...observeSession(event, state), ...mapEvent(event, state)];
+}
+/**
+* droid names its session on every stream event, from the first `system`
+* init on. Report it at the first event, not at the final result, so a turn
+* killed mid-run still names the session file it was writing.
+*/
+function observeSession(event, state) {
+	const sessionId = event.session_id;
+	if (typeof sessionId !== "string" || !sessionId) return [];
+	if (state.sessionId === sessionId) return [];
+	return sessionObservedEvents(state, "factory-droids", sessionId);
+}
+function mapEvent(event, state) {
+	switch (event.type) {
+		case "assistant": return textDeltaEvents(state, event.content);
+		case "thinking": return reasoningEvents(state, event.content, { signalPhase: true });
+		case "tool_use": return toolStartEvents(state, event);
+		case "tool_result": return mapToolResultEvent(event, state);
+		case "system": return mapSystemEvent(event);
+		case "error": return mapErrorEvent(event);
+		case "result": return mapResultEvent(event, state);
+		case "message": return mapMessageEvent(event, state);
+		case "tool_call": return mapToolCallEvent(event, state);
+		case "completion": return mapCompletionEvent(event, state);
+		default: return [{
+			type: "raw",
+			backend: "factory-droids",
+			event
+		}];
+	}
+}
+//#endregion
+//#region src/adapters/factory-droids/adapter.ts
+const DEFAULT_MODEL = "claude-opus-4-5-20251101";
+/**
+* A caller-owned OpenAI-compatible endpoint (`baseUrl` + `apiKey`) runs as a
+* droid custom model. droid reads it from a runtime settings file passed with
+* `--settings`; the file names the key by this env var, which droid expands,
+* so the key never lands on disk. Factory's own account is not used. The
+* custom model's id is `custom:<model>`, the id droid records in its session.
+*/
+const ENDPOINT_API_KEY_ENV = "TANGLE_DROID_ENDPOINT_API_KEY";
+const ENDPOINT_SETTINGS_PREFIX = ".tangle-droid-endpoint-";
+/** Name of the interaction MCP server registered into `.factory/mcp.json`. */
+const DROID_INTERACTION_MCP_NAME = "tangle-interaction";
+/**
+* Factory Droids provider adapter.
+*
+* Implements the SdkProviderAdapter interface for the Factory Droids CLI tool.
+* Extends CliProviderAdapterBase with Factory Droids-specific event parsing and CLI arguments.
+*/
+var FactoryDroidsProviderAdapter = class extends CliProviderAdapterBase {
+	provider = "factory-droids";
+	defaultCliPath = "droid";
+	/**
+	* Shared interaction round-trip for questions. droid auto-discovers
+	* MCP tools, so the agent calls `ask_user` itself; permission
+	* stays governed by droid's own `--auto` / `--skip-permissions-unsafe`.
+	*/
+	activeInteractions;
+	configuredInteractionKinds(interactions = this.config.interactions) {
+		return enabledInteractionKinds(interactions, ["question"]).map(() => InteractionKind.Question);
+	}
+	getCapabilities() {
+		const interactions = this.configuredInteractionKinds();
+		return {
+			...super.getCapabilities(),
+			...interactions.length > 0 ? { interactions } : {}
+		};
+	}
+	/**
+	* Host a per-execution interaction MCP server when `interactions` is on and
+	* register it into the SAME `$HOME/.factory/mcp.json` that `droid exec` reads
+	* (HOME resolved exactly as the base adapter's exec env resolves it, so the
+	* write lands where droid looks). The entry is removed and every pending
+	* interaction failed-closed in `finally` when the turn unwinds.
+	*/
+	async execute(input, services, onEvent) {
+		const turnConfig = withTurnInteractions(this.config, input);
+		const kinds = this.configuredInteractionKinds(turnConfig.interactions);
+		if (kinds.length === 0) return super.execute(input, services, onEvent);
+		const sessionId = input.sessionId ?? input.interactionBinding?.sessionId ?? randomUUID();
+		const workspaceRoot = input.workspaceRoot ?? this.storagePath;
+		const home = this.applyWritableHomeDefaults(this.buildExecEnv(this.config), workspaceRoot).HOME ?? workspaceRoot;
+		const interactions = new McpInteractionSupport(DROID_INTERACTION_MCP_NAME, kinds);
+		this.activeInteractions = interactions;
+		const server = await interactions.start(sessionId, this.interactionExecutionBinding(input, sessionId), onEvent);
+		await upsertDroidMcpEntry(home, DROID_INTERACTION_MCP_NAME, {
+			type: "http",
+			url: server.url,
+			headers: { Authorization: `Bearer ${server.token}` }
+		});
+		try {
+			return await super.execute(input, services, onEvent);
+		} finally {
+			await removeDroidMcpEntry(home, DROID_INTERACTION_MCP_NAME).catch(() => {});
+			this.activeInteractions = void 0;
+			await interactions.stop(sessionId);
+		}
+	}
+	async respondToInteraction(response) {
+		this.activeInteractions?.respond(response);
+	}
+	/**
+	* Initialize the adapter with API key validation.
+	* Factory Droids requires an API key to function.
+	*/
+	async afterInitialize(config) {
+		if (!(config.model?.apiKey ?? this.config.apiKey ?? process.env.FACTORY_API_KEY)) throw new Error("API key is required for Factory Droids. Set FACTORY_API_KEY environment variable or provide apiKey in config.");
+	}
+	buildExecArgs(params) {
+		const args = ["exec"];
+		const model = params.model ?? params.config.model ?? DEFAULT_MODEL;
+		const baseUrl = params.config.baseUrl?.trim();
+		if (baseUrl) {
+			const home = this.config.runtimeHome?.trim() || params.workspaceRoot;
+			args.push("--settings", writeEndpointSettings(home, {
+				model,
+				baseUrl
+			}), "--model", `custom:${model}`);
+		} else args.push("--model", model);
+		if (params.config.bypassPermissions !== false) args.push("--skip-permissions-unsafe");
+		else if (params.config.autonomyLevel) args.push("--auto", params.config.autonomyLevel);
+		args.push("--output-format", "stream-json");
+		args.push("--cwd", params.workspaceRoot);
+		if (params.systemPrompt) args.push("--append-system-prompt", params.systemPrompt);
+		if (params.config.extraFlags) args.push(...params.config.extraFlags);
+		if (params.sessionId) args.push("--session-id", params.sessionId);
+		args.push(params.message);
+		return {
+			command: this.getCliPath(),
+			args,
+			useStdin: false
+		};
+	}
+	buildExecEnv(config) {
+		const env = this.agentEnvironmentValues();
+		if (config.baseUrl?.trim()) {
+			if (!config.apiKey) throw new Error("Factory Droids on a caller endpoint (baseUrl) needs that endpoint's apiKey.");
+			env[ENDPOINT_API_KEY_ENV] = config.apiKey;
+			delete env.FACTORY_API_KEY;
+			return env;
+		}
+		const apiKey = config.apiKey ?? process.env.FACTORY_API_KEY;
+		if (apiKey) env.FACTORY_API_KEY = apiKey;
+		return env;
+	}
+	createEventParser(state, onEvent) {
+		return jsonEventParser(this.logger, onEvent, {
+			label: "Factory Droids",
+			accept: isFactoryDroidsEvent,
+			map: (event) => mapFactoryDroidsEvent(event, state)
+		});
+	}
+	buildMcpAddArgs(name, config) {
+		const args = [
+			"mcp",
+			"add",
+			name
+		];
+		if (isLocalMcpConfig(config)) {
+			args.push("--type", "stdio", ...localMcpArgv(config));
+			for (const [key, value] of Object.entries(localMcpEnv(config) ?? {})) args.push("--env", `${key}=${value}`);
+		} else {
+			args.push("--type", "http", config.url);
+			for (const [key, value] of Object.entries(config.headers ?? {})) args.push("--header", `${key}: ${value}`);
+		}
+		return args;
+	}
+};
+/**
+* Read–merge–write a single HTTP server into `<home>/.factory/mcp.json`. droid
+* reads this file at `droid exec` startup; the shape is the standard
+* `{ mcpServers: { <name>: { type, url, headers } } }` (verified against
+* `droid mcp add --type http`). Merges into any existing config so a tenant's
+* own servers survive; overwrites our own entry idempotently across turns.
+*/
+async function upsertDroidMcpEntry(home, name, entry) {
+	const dir = join(home, ".factory");
+	const file = join(dir, "mcp.json");
+	await mkdir(dir, { recursive: true });
+	const doc = await readMcpDoc(file);
+	doc.mcpServers[name] = entry;
+	await writeFile(file, `${JSON.stringify(doc, null, 2)}\n`, "utf8");
+}
+/** Remove our entry from `<home>/.factory/mcp.json` (best-effort teardown). */
+async function removeDroidMcpEntry(home, name) {
+	const file = join(home, ".factory", "mcp.json");
+	const doc = await readMcpDoc(file);
+	if (!(name in doc.mcpServers)) return;
+	delete doc.mcpServers[name];
+	await writeFile(file, `${JSON.stringify(doc, null, 2)}\n`, "utf8");
+}
+async function readMcpDoc(file) {
+	try {
+		const parsed = JSON.parse(await readFile(file, "utf8"));
+		const servers = parsed?.mcpServers;
+		return {
+			...parsed,
+			mcpServers: servers && typeof servers === "object" ? servers : {}
+		};
+	} catch {
+		return { mcpServers: {} };
+	}
+}
+/**
+* Write the runtime settings that declare the caller's endpoint as droid's
+* custom model, and return the file's path. The key stays an env reference.
+*/
+function writeEndpointSettings(home, endpoint) {
+	const path = join(home, `${ENDPOINT_SETTINGS_PREFIX}${createHash("sha256").update(`${endpoint.baseUrl}\n${endpoint.model}`).digest("hex").slice(0, 16)}.settings.json`);
+	const candidate = join(home, `.${randomUUID()}.droid-settings`);
+	try {
+		writeFileSync(candidate, `${JSON.stringify({ customModels: [{
+			id: `custom:${endpoint.model}`,
+			displayName: "tangle-endpoint",
+			model: endpoint.model,
+			baseUrl: endpoint.baseUrl,
+			apiKey: `\${${ENDPOINT_API_KEY_ENV}}`,
+			provider: "generic-chat-completion-api"
+		}] }, null, 2)}\n`, {
+			mode: 420,
+			flag: "wx"
+		});
+		renameSync(candidate, path);
+	} catch (error) {
+		rmSync(candidate, { force: true });
+		throw error;
+	}
+	return path;
+}
+//#endregion
+export { FactoryDroidsProviderAdapter, isFactoryDroidsEvent, mapFactoryDroidsEvent };
+
+//# sourceMappingURL=index.mjs.map

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

@@ -0,0 +1,27 @@
+import { Mt as CliExecArgs, Pt as CliProviderConfig, Rt as ExecutionState, ht as CliProviderAdapterBase } from "../../index-BpO3fvbf.mjs";
+import { StreamParserConfig } from "@tangle-network/sdk-cli-runner";
+import { StreamEvent } from "@tangle-network/agent-interface";
+
+//#region src/adapters/grok/adapter.d.ts
+type GrokLine = {
+  type: "text";
+  line: string;
+};
+declare class GrokProviderAdapter extends CliProviderAdapterBase<CliProviderConfig, GrokLine> {
+  readonly provider = "grok";
+  protected readonly defaultCliPath = "grok";
+  protected buildExecArgs(params: {
+    message: string;
+    config: CliProviderConfig;
+    model?: string;
+    sessionId?: string;
+    workspaceRoot: string;
+    systemPrompt?: string;
+  }): CliExecArgs;
+  /** The host agent environment, with the turn's key and endpoint over it. */
+  protected buildExecEnv(config: CliProviderConfig): Record<string, string | undefined>;
+  protected createEventParser(state: ExecutionState, onEvent?: (event: StreamEvent) => void): StreamParserConfig<GrokLine>;
+}
+//#endregion
+export { GrokProviderAdapter };
+//# sourceMappingURL=index.d.mts.map

package/dist/adapters/grok/index.mjs

@@ -0,0 +1,56 @@
+import { H as CliProviderAdapterBase, I as plaintextResponseParser, Tt as sessionObservedEvents, ot as prependPromptSection } from "../../src-Fn8Pu1xq.mjs";
+//#region src/adapters/grok/adapter.ts
+const DECLARE_MODEL = "d=$HOME/.grok; [ -z \"$GROK_HOME\" ] || d=$GROK_HOME; t=\"[model.\\\"$1\\\"]\"; mkdir -p \"$d\" && { grep -qxF \"$t\" \"$d/managed_config.toml\" 2>/dev/null || printf '%s\\nmodel = \"%s\"\\n' \"$t\" \"$1\" >> \"$d/managed_config.toml\"; }; shift; exec \"$@\"";
+var GrokProviderAdapter = class extends CliProviderAdapterBase {
+	provider = "grok";
+	defaultCliPath = "grok";
+	buildExecArgs(params) {
+		const args = [
+			"--always-approve",
+			"--output-format",
+			"streaming-json"
+		];
+		const model = params.model ?? params.config.model ?? "";
+		if (model) args.push("-m", model);
+		if (params.sessionId) args.push("-r", params.sessionId);
+		args.push("-p", prependPromptSection(params.systemPrompt, params.message));
+		if (!params.config.baseUrl?.trim() || !/^[\w.:@+/-]+$/.test(model)) return {
+			command: this.getCliPath(),
+			args,
+			useStdin: false
+		};
+		args.unshift("-c", DECLARE_MODEL, "grok", model, this.getCliPath());
+		return {
+			command: "/bin/sh",
+			args,
+			useStdin: false
+		};
+	}
+	/** The host agent environment, with the turn's key and endpoint over it. */
+	buildExecEnv(config) {
+		const env = this.agentEnvironmentValues();
+		if (config.apiKey) env.XAI_API_KEY = config.apiKey;
+		const baseUrl = config.baseUrl?.trim();
+		if (baseUrl) env.GROK_MODELS_BASE_URL = baseUrl;
+		return env;
+	}
+	createEventParser(state, onEvent) {
+		return plaintextResponseParser(state, onEvent, {
+			classify: (line) => line.length === 0 ? null : {
+				type: "text",
+				line
+			},
+			map: (event, response) => {
+				response.text(event.line);
+				const id = /"sessionId"\s*:\s*"([^"]+)"/.exec(event.line)?.[1];
+				if (!id || state.sessionId === id) return [];
+				return sessionObservedEvents(state, "grok", id);
+			},
+			emptyFailureDetail: "grok exited without producing a response body"
+		});
+	}
+};
+//#endregion
+export { GrokProviderAdapter };
+
+//# sourceMappingURL=index.mjs.map

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

@@ -0,0 +1,148 @@
+import { Mt as CliExecArgs, Pt as CliProviderConfig, Rt as ExecutionState, ht as CliProviderAdapterBase, n as HarnessId } from "../../index-BpO3fvbf.mjs";
+import { i as PreparedAttachment } from "../../prompt-input-CD7okX8T.mjs";
+import { StreamParserConfig } from "@tangle-network/sdk-cli-runner";
+import { InputPart, McpConfig, StreamEvent } from "@tangle-network/agent-interface";
+import { MessagePart } from "@tangle-network/sdk-session-persistence";
+
+//#region src/adapters/hermes/types.d.ts
+/**
+ * Authentication mode for hermes.
+ *
+ * - "api-key": Use the provider-specific key env (OPENROUTER_API_KEY,
+ *   ANTHROPIC_API_KEY, …) from `apiKey` or env. The adapter sets the env var
+ *   for the provider chosen by `inferenceProvider`.
+ * - "oauth": Use Nous Portal OAuth tokens previously stored via `hermes login`
+ *   (or `hermes auth add ... --type oauth`). The CLI reads them from
+ *   `$HERMES_HOME/.env` or its credential store.
+ */
+type HermesAuthMode = "api-key" | "oauth";
+/**
+ * Inference provider hermes will route the model call through. Subset of the
+ * providers hermes supports natively (`hermes --provider …`). The list here is
+ * intentionally narrow to the providers we plumb env vars for in the adapter;
+ * hermes accepts a wider set for end-user CLI use.
+ */
+type HermesInferenceProvider = "auto" | "openrouter" | "anthropic" | "openai-codex" | "nous" | "custom";
+/**
+ * Hermes-specific configuration.
+ */
+interface HermesConfig extends CliProviderConfig {
+  /** Path to the hermes CLI executable. Default: "hermes" (resolved on PATH). */
+  cliPath?: string;
+  /** Model to use (e.g. "anthropic/claude-sonnet-4"). Forwarded as `--model`. */
+  model?: string;
+  /**
+   * Inference provider for the model call. Forwarded as `--provider`.
+   */
+  inferenceProvider?: HermesInferenceProvider;
+  /**
+   * Authentication mode. Defaults to "api-key" when an apiKey is present;
+   * otherwise "oauth" (which assumes the CLI's credential store is populated).
+   */
+  authMode?: HermesAuthMode;
+  /**
+   * Optional auth files to materialize under `$HOME` before invoking the CLI.
+   * Hermes reads its API keys from `$HERMES_HOME/.env` and OAuth tokens from
+   * `$HERMES_HOME/credentials/*` — both targets work via the standard authFile
+   * materialization pipeline (see apps/sidecar/src/backends/cli-auth.ts).
+   */
+  authFiles?: Array<{
+    path: string;
+    content: string;
+    mode?: number;
+  }>;
+  /**
+   * API key. When present, written to the env var matching `inferenceProvider`
+   * (`OPENROUTER_API_KEY` for openrouter, `ANTHROPIC_API_KEY` for anthropic,
+   * etc). Used only when `authMode === "api-key"`.
+   */
+  apiKey?: string;
+  /**
+   * Base URL for the inference provider. Forwarded as a provider-specific env
+   * var (`OPENROUTER_BASE_URL` for openrouter, etc) so hermes routes through
+   * a custom endpoint like `https://router.tangle.tools/v1`.
+   */
+  baseUrl?: string;
+  /** Comma-separated toolsets to enable via `--toolsets`. */
+  toolsets?: string[];
+  /**
+   * Extra flags appended before the terminal `-q <prompt>` pair.
+   */
+  extraFlags?: string[];
+}
+/**
+ * Emitted for every stdout line — accumulated into the response text. Quiet
+ * mode prints only the final content block, so the entire stream is body text.
+ */
+interface HermesTextEvent {
+  type: "text";
+  line: string;
+}
+/**
+ * Emitted when stdout closes; carries the full accumulated response so the
+ * adapter can synthesize a final `message.part.updated` and `result` event.
+ */
+interface HermesCompleteEvent {
+  type: "complete";
+  text: string;
+}
+/**
+ * Emitted when hermes exits non-zero or prints a recognizable error pattern.
+ * `message` is the raw line so callers can surface the upstream message verbatim.
+ */
+interface HermesErrorEvent {
+  type: "error";
+  message: string;
+}
+type HermesEvent = HermesTextEvent | HermesCompleteEvent | HermesErrorEvent;
+//#endregion
+//#region src/adapters/hermes/adapter.d.ts
+declare class HermesProviderAdapter extends CliProviderAdapterBase<HermesConfig, HermesEvent> {
+  readonly provider = "hermes";
+  protected readonly profileHarness: HarnessId;
+  private activeSessionId?;
+  protected readonly defaultCliPath = "hermes";
+  protected isBenignNonZeroExit({
+    exitCode,
+    stderr,
+    state
+  }: {
+    exitCode: number | null;
+    stderr: string;
+    state: ExecutionState;
+  }): boolean;
+  protected buildMcpAddArgs(name: string, config: McpConfig): string[];
+  /** The contract store, or a workspace fallback when no runtime home is set. */
+  private resolveHermesHome;
+  protected preparePromptInput(parts: InputPart[], workspaceRoot: string, sessionId: string): Promise<{
+    promptText: string;
+    persistedParts: MessagePart[];
+    attachments: PreparedAttachment[];
+  }>;
+  protected nativeAttachmentKinds(): ReadonlyArray<"image" | "file">;
+  protected buildExecArgs(params: {
+    message: string;
+    config: HermesConfig;
+    model?: string;
+    sessionId?: string;
+    workspaceRoot: string;
+    systemPrompt?: string;
+    attachments?: PreparedAttachment[];
+  }): CliExecArgs;
+  private releaseTurnLease;
+  protected buildExecEnv(config: HermesConfig): Record<string, string | undefined>;
+  protected afterCliProcessExit(params: {
+    state: ExecutionState;
+    stderr: string;
+    exit: {
+      success: boolean;
+    };
+    workspaceRoot: string;
+    env: Record<string, string | undefined>;
+    onEvent?: (event: StreamEvent) => void;
+  }): Promise<void>;
+  protected createEventParser(state: ExecutionState, onEvent?: (event: StreamEvent) => void): StreamParserConfig<HermesEvent>;
+}
+//#endregion
+export { type HermesAuthMode, type HermesCompleteEvent, type HermesConfig, type HermesErrorEvent, type HermesEvent, type HermesInferenceProvider, HermesProviderAdapter, type HermesTextEvent };
+//# sourceMappingURL=index.d.mts.map