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

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

@@ -0,0 +1,250 @@
+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 { McpConfig, ProviderConfig, StreamEvent } from "@tangle-network/agent-interface";
+
+//#region src/adapters/amp/types.d.ts
+/**
+ * Text content block.
+ */
+interface AmpTextBlock {
+  type: "text";
+  text: string;
+}
+/**
+ * Tool use request block.
+ */
+interface AmpToolUseBlock {
+  type: "tool_use";
+  id: string;
+  name: string;
+  input: Record<string, unknown>;
+}
+/**
+ * Tool result block (appears in user messages).
+ */
+interface AmpToolResultBlock {
+  type: "tool_result";
+  tool_use_id: string;
+  content: string | unknown;
+  is_error?: boolean;
+}
+/**
+ * Thinking/reasoning content block.
+ * Only present when `--stream-json-thinking` is used.
+ */
+interface AmpThinkingBlock {
+  type: "thinking";
+  thinking: string;
+}
+/**
+ * Redacted thinking block.
+ */
+interface AmpRedactedThinkingBlock {
+  type: "redacted_thinking";
+  data: string;
+}
+/**
+ * Union of all content block types.
+ */
+type AmpContentBlock = AmpTextBlock | AmpToolUseBlock | AmpToolResultBlock | AmpThinkingBlock | AmpRedactedThinkingBlock;
+/**
+ * Token usage statistics.
+ */
+interface AmpTokenUsage {
+  input_tokens: number;
+  output_tokens: number;
+  max_tokens?: number;
+  cache_creation_input_tokens?: number;
+  cache_read_input_tokens?: number;
+  service_tier?: string;
+}
+/**
+ * Assistant message structure.
+ */
+interface AmpAssistantMessage {
+  type: "message";
+  role: "assistant";
+  content: AmpContentBlock[];
+  stop_reason?: "end_turn" | "tool_use" | "max_tokens" | null;
+  usage?: AmpTokenUsage;
+}
+/**
+ * User message structure (contains tool results).
+ */
+interface AmpUserMessage {
+  role: "user";
+  content: AmpToolResultBlock[];
+}
+/**
+ * MCP server status in init event.
+ */
+interface AmpMcpServerInfo {
+  name: string;
+  status: string;
+}
+/**
+ * System initialization event.
+ * Emitted at the start of execution with environment details.
+ */
+interface AmpSystemEvent {
+  type: "system";
+  subtype: "init";
+  cwd: string;
+  session_id: string;
+  tools: string[];
+  mcp_servers: AmpMcpServerInfo[];
+}
+/**
+ * User event (contains tool results).
+ */
+interface AmpUserEvent {
+  type: "user";
+  message: AmpUserMessage;
+  parent_tool_use_id: string | null;
+  session_id: string;
+}
+/**
+ * Assistant event (model response with content blocks).
+ */
+interface AmpAssistantEvent {
+  type: "assistant";
+  message: AmpAssistantMessage;
+  parent_tool_use_id: string | null;
+  session_id: string;
+}
+/**
+ * Success result event.
+ */
+interface AmpSuccessResultEvent {
+  type: "result";
+  subtype: "success";
+  duration_ms: number;
+  is_error: false;
+  num_turns: number;
+  result: string;
+  session_id: string;
+  usage?: AmpTokenUsage;
+  permission_denials?: string[];
+}
+/**
+ * Error result event.
+ */
+interface AmpErrorResultEvent {
+  type: "result";
+  subtype: "error_during_execution" | "error_max_turns";
+  duration_ms: number;
+  is_error: true;
+  num_turns: number;
+  error: string;
+  session_id: string;
+  usage?: AmpTokenUsage;
+  permission_denials?: string[];
+}
+/**
+ * Union of result event types.
+ */
+type AmpResultEvent = AmpSuccessResultEvent | AmpErrorResultEvent;
+/**
+ * Union of all AMP events.
+ */
+type AmpEvent = AmpSystemEvent | AmpUserEvent | AmpAssistantEvent | AmpResultEvent;
+/**
+ * Configuration for the AMP provider.
+ * Extends the shared CliProviderConfig with AMP-specific options.
+ */
+interface AmpConfig extends CliProviderConfig {
+  /** Path to the amp CLI (default: "amp") */
+  cliPath?: string;
+  /** Default model to use (AMP uses claude-opus-4-5-20251101 by default) */
+  model?: string;
+  /** API key for AMP (can also use AMP_API_KEY env var) */
+  apiKey?: string;
+  /** Include thinking/reasoning in output (adds --stream-json-thinking) */
+  includeThinking?: boolean;
+  /**
+   * Bypass all permission checks for fully autonomous operation.
+   * Uses --dangerously-allow-all flag.
+   * Default: true (for headless/automated use)
+   */
+  bypassPermissions?: boolean;
+  /** Extra flags to pass to the CLI */
+  extraFlags?: string[];
+  /** Workspace settings path override */
+  workspaceSettingsPath?: string;
+}
+/**
+ * Type guard for AMP events.
+ */
+declare function isAmpEvent(value: unknown): value is AmpEvent;
+/**
+ * Type guard for text blocks.
+ */
+declare function isTextBlock(block: AmpContentBlock): block is AmpTextBlock;
+/**
+ * Type guard for tool use blocks.
+ */
+declare function isToolUseBlock(block: AmpContentBlock): block is AmpToolUseBlock;
+/**
+ * Type guard for tool result blocks.
+ */
+declare function isToolResultBlock(block: AmpContentBlock): block is AmpToolResultBlock;
+/**
+ * Type guard for thinking blocks.
+ */
+declare function isThinkingBlock(block: AmpContentBlock): block is AmpThinkingBlock;
+//#endregion
+//#region src/adapters/amp/adapter.d.ts
+/**
+ * AMP (Sourcegraph) provider adapter.
+ *
+ * Implements the SdkProviderAdapter interface for the AMP CLI tool.
+ * Extends CliProviderAdapterBase with AMP-specific event parsing and CLI arguments.
+ *
+ * Key differences from other CLI providers:
+ * - Uses `-x` (execute) mode for non-interactive operation
+ * - Uses `--stream-json` and `--stream-json-input` for structured I/O
+ * - Session continuation uses `amp threads continue [thread_id]`
+ * - Events have a nested structure with `assistant.message.content[]`
+ */
+declare class AmpProviderAdapter extends CliProviderAdapterBase<AmpConfig, AmpEvent> {
+  readonly provider = "amp";
+  protected readonly defaultCliPath = "amp";
+  protected buildExecArgs(params: {
+    message: string;
+    config: AmpConfig;
+    model?: string;
+    sessionId?: string;
+    workspaceRoot: string;
+    systemPrompt?: string;
+  }): CliExecArgs;
+  /**
+   * Refuse a run that has no Amp credential. Without `AMP_API_KEY` or login
+   * files the amp CLI prints a device-login URL and waits for a person to
+   * confirm it in a browser, so a headless turn produces no event until its
+   * timeout. Amp is a hosted service of its own: the Tangle Router has no
+   * managed credential for it, so a managed box carries none, and the caller
+   * supplies the access token (`backend.model.apiKey`) or login files.
+   */
+  protected afterInitialize(config: ProviderConfig): Promise<void>;
+  protected buildExecEnv(config: AmpConfig): Record<string, string | undefined>;
+  protected createEventParser(state: ExecutionState, onEvent?: (event: StreamEvent) => void): StreamParserConfig<AmpEvent>;
+  protected formatStdinMessage(message: string): string;
+  protected buildMcpAddArgs(name: string, config: McpConfig): string[];
+  protected buildMcpListArgs(): string[] | null;
+}
+//#endregion
+//#region src/adapters/amp/event-mapper.d.ts
+/**
+ * Maps an AMP 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 AMP event
+ * @param state - The execution state (mutated by this function)
+ * @returns Array of StreamEvents
+ */
+declare function mapAmpEvent(event: AmpEvent, state: ExecutionState): StreamEvent[];
+//#endregion
+export { type AmpAssistantEvent, type AmpAssistantMessage, type AmpConfig, type AmpContentBlock, type AmpErrorResultEvent, type AmpEvent, type AmpMcpServerInfo, AmpProviderAdapter, type AmpRedactedThinkingBlock, type AmpResultEvent, type AmpSuccessResultEvent, type AmpSystemEvent, type AmpTextBlock, type AmpThinkingBlock, type AmpTokenUsage, type AmpToolResultBlock, type AmpToolUseBlock, type AmpUserEvent, type AmpUserMessage, isAmpEvent, isTextBlock, isThinkingBlock, isToolResultBlock, isToolUseBlock, mapAmpEvent };
+//# sourceMappingURL=index.d.mts.map

package/dist/adapters/amp/index.mjs

@@ -0,0 +1,233 @@
+import { At as toolStartEvents, Dt as textDeltaEvents, F as jsonEventParser, H as CliProviderAdapterBase, K as localMcpArgv, Tt as sessionObservedEvents, V as recordCliTokenUsage, kt as toolResultEvents, q as localMcpEnv, wt as reasoningEvents } from "../../src-Fn8Pu1xq.mjs";
+//#region src/adapters/amp/types.ts
+/**
+* Type guard for AMP events.
+*/
+function isAmpEvent(value) {
+	if (typeof value !== "object" || value === null) return false;
+	return typeof value.type === "string";
+}
+/**
+* Type guard for text blocks.
+*/
+function isTextBlock(block) {
+	return block.type === "text";
+}
+/**
+* Type guard for tool use blocks.
+*/
+function isToolUseBlock(block) {
+	return block.type === "tool_use";
+}
+/**
+* Type guard for tool result blocks.
+*/
+function isToolResultBlock(block) {
+	return block.type === "tool_result";
+}
+/**
+* Type guard for thinking blocks.
+*/
+function isThinkingBlock(block) {
+	return block.type === "thinking";
+}
+//#endregion
+//#region src/adapters/amp/event-mapper.ts
+/**
+* Maps an AMP system init event to StreamEvents.
+*/
+function mapSystemEvent(event, state) {
+	return [...sessionObservedEvents(state, "amp", event.session_id), {
+		type: "status",
+		status: "processing",
+		detail: `Initialized in ${event.cwd} with ${event.tools.length} tools`
+	}];
+}
+/**
+* Maps an AMP user event (tool results) to StreamEvents.
+* User events contain tool results that update the state of pending tool calls.
+*/
+function mapUserEvent(event, state) {
+	const events = [];
+	for (const block of event.message.content) if (isToolResultBlock(block)) events.push(...toolResultEvents(state, {
+		id: block.tool_use_id,
+		content: block.content,
+		isError: Boolean(block.is_error)
+	}));
+	return events;
+}
+/**
+* Maps an AMP assistant event to StreamEvents.
+* Assistant events contain content blocks (text, tool_use, thinking).
+*/
+function mapAssistantEvent(event, state) {
+	const events = [];
+	for (const block of event.message.content) events.push(...mapContentBlock(block, state));
+	recordCliTokenUsage(state, event.message);
+	return events;
+}
+/**
+* Maps an individual content block to StreamEvents.
+*/
+function mapContentBlock(block, state) {
+	if (isTextBlock(block)) return textDeltaEvents(state, block.text);
+	if (isToolUseBlock(block)) return toolStartEvents(state, block);
+	if (isThinkingBlock(block)) return reasoningEvents(state, block.thinking, { signalPhase: true });
+	return [{
+		type: "raw",
+		backend: "amp",
+		event: block
+	}];
+}
+/**
+* Maps an AMP result event to StreamEvents.
+*/
+function mapResultEvent(event, state) {
+	const events = sessionObservedEvents(state, "amp", event.session_id);
+	recordCliTokenUsage(state, event);
+	if (event.is_error) events.push({
+		type: "warning",
+		code: event.subtype.toUpperCase(),
+		message: event.error
+	});
+	if (event.permission_denials && event.permission_denials.length > 0) events.push({
+		type: "warning",
+		code: "PERMISSION_DENIED",
+		message: `Permission denied for: ${event.permission_denials.join(", ")}`
+	});
+	events.push({
+		type: "status",
+		status: event.is_error ? "failed" : "completed",
+		detail: event.is_error ? event.error : void 0
+	});
+	return events;
+}
+/**
+* Maps an AMP 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 AMP event
+* @param state - The execution state (mutated by this function)
+* @returns Array of StreamEvents
+*/
+function mapAmpEvent(event, state) {
+	switch (event.type) {
+		case "system": return mapSystemEvent(event, state);
+		case "user": return mapUserEvent(event, state);
+		case "assistant": return mapAssistantEvent(event, state);
+		case "result": return mapResultEvent(event, state);
+		default: return [{
+			type: "raw",
+			backend: "amp",
+			event
+		}];
+	}
+}
+//#endregion
+//#region src/adapters/amp/adapter.ts
+/**
+* AMP (Sourcegraph) provider adapter.
+*
+* Implements the SdkProviderAdapter interface for the AMP CLI tool.
+* Extends CliProviderAdapterBase with AMP-specific event parsing and CLI arguments.
+*
+* Key differences from other CLI providers:
+* - Uses `-x` (execute) mode for non-interactive operation
+* - Uses `--stream-json` and `--stream-json-input` for structured I/O
+* - Session continuation uses `amp threads continue [thread_id]`
+* - Events have a nested structure with `assistant.message.content[]`
+*/
+var AmpProviderAdapter = class extends CliProviderAdapterBase {
+	provider = "amp";
+	defaultCliPath = "amp";
+	buildExecArgs(params) {
+		const args = [];
+		if (params.config.bypassPermissions !== false) args.push("--dangerously-allow-all");
+		if (params.sessionId) args.push("threads", "continue", params.sessionId);
+		args.push(params.sessionId ? "-x" : `--execute=${params.message}`);
+		args.push("--stream-json");
+		if (params.config.includeThinking !== false) args.push("--stream-json-thinking");
+		if (params.config.extraFlags) args.push(...params.config.extraFlags);
+		if (params.sessionId) {
+			args.push("--stream-json-input");
+			return {
+				command: this.getCliPath(),
+				args,
+				useStdin: true
+			};
+		}
+		return {
+			command: this.getCliPath(),
+			args,
+			useStdin: false
+		};
+	}
+	/**
+	* Refuse a run that has no Amp credential. Without `AMP_API_KEY` or login
+	* files the amp CLI prints a device-login URL and waits for a person to
+	* confirm it in a browser, so a headless turn produces no event until its
+	* timeout. Amp is a hosted service of its own: the Tangle Router has no
+	* managed credential for it, so a managed box carries none, and the caller
+	* supplies the access token (`backend.model.apiKey`) or login files.
+	*/
+	async afterInitialize(config) {
+		const apiKey = config.model?.apiKey ?? this.config.apiKey ?? process.env.AMP_API_KEY;
+		const authFiles = config.model?.authFiles ?? this.config.authFiles;
+		if (!apiKey && (authFiles?.length ?? 0) === 0) throw new Error("An Amp credential is required: set AMP_API_KEY, or provide backend.model.apiKey (an Amp access token) or login files. The Tangle Router does not provide Amp credentials.");
+	}
+	buildExecEnv(config) {
+		const env = this.agentEnvironmentValues();
+		const apiKey = config.apiKey ?? process.env.AMP_API_KEY;
+		if (apiKey) env.AMP_API_KEY = apiKey;
+		env.AMP_SKIP_UPDATE_CHECK = "1";
+		return env;
+	}
+	createEventParser(state, onEvent) {
+		return jsonEventParser(this.logger, onEvent, {
+			label: "AMP",
+			accept: isAmpEvent,
+			map: (event) => mapAmpEvent(event, state)
+		});
+	}
+	formatStdinMessage(message) {
+		return JSON.stringify({
+			type: "user",
+			message: {
+				role: "user",
+				content: [{
+					type: "text",
+					text: message
+				}]
+			}
+		});
+	}
+	buildMcpAddArgs(name, config) {
+		const args = [
+			"mcp",
+			"add",
+			"--workspace",
+			name
+		];
+		if (config.type === "http" || config.type === "remote") {
+			this.logger.warn("AMP may not support remote MCP servers directly", {
+				name,
+				url: config.url
+			});
+			args.push("--", "echo", `Remote MCP not supported: ${config.url}`);
+		} else {
+			const envEntries = localMcpEnv(config);
+			if (envEntries && Object.keys(envEntries).length > 0) throw new Error(`amp: MCP server "${name}" declares environment variables (${Object.keys(envEntries).sort().join(", ")}) but the amp CLI exposes no way to pass them to the server process. Use a backend whose CLI accepts MCP env vars, or drop the env from the config.`);
+			args.push("--", ...localMcpArgv(config));
+		}
+		return args;
+	}
+	buildMcpListArgs() {
+		return ["mcp", "list"];
+	}
+};
+//#endregion
+export { AmpProviderAdapter, isAmpEvent, isTextBlock, isThinkingBlock, isToolResultBlock, isToolUseBlock, mapAmpEvent };
+
+//# sourceMappingURL=index.mjs.map

package/dist/adapters/factory-droids/index.d.mts

@@ -0,0 +1,200 @@
+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 { AgentExecutionInput, AgentExecutionResult, BackendCapabilities, InteractionResponse, McpConfig, ProviderConfig, SdkHostServices, StreamEvent } from "@tangle-network/agent-interface";
+
+//#region src/adapters/factory-droids/types.d.ts
+/**
+ * Assistant text content event.
+ */
+interface FactoryDroidsAssistantEvent {
+  type: "assistant";
+  content: string;
+}
+/**
+ * Thinking/reasoning content event.
+ */
+interface FactoryDroidsThinkingEvent {
+  type: "thinking";
+  content: string;
+}
+/**
+ * Tool use request event.
+ */
+interface FactoryDroidsToolUseEvent {
+  type: "tool_use";
+  id: string;
+  name: string;
+  input: unknown;
+}
+/**
+ * Tool result event.
+ */
+interface FactoryDroidsToolResultEvent {
+  type: "tool_result";
+  tool_use_id: string;
+  content: string | unknown;
+  is_error?: boolean;
+}
+/**
+ * System message event.
+ */
+interface FactoryDroidsSystemEvent {
+  type: "system";
+  content: string;
+}
+/**
+ * Error event.
+ */
+interface FactoryDroidsErrorEvent {
+  type: "error";
+  /** droid 0.238.0 names the failure here, e.g. `{type:"error",source:"cli",message}`. */
+  message?: string;
+  content?: string;
+  source?: string;
+  code?: string;
+}
+/**
+ * Final result event.
+ */
+interface FactoryDroidsResultEvent {
+  type: "result";
+  text: string;
+  session_id?: string;
+  usage?: {
+    input_tokens?: number;
+    output_tokens?: number;
+    cache_read_input_tokens?: number;
+    cache_creation_input_tokens?: number;
+  };
+}
+/**
+ * Union of all Factory Droids events.
+ */
+/**
+ * droid ≥0.159 stream-json schema. The earlier `assistant`/`tool_use`/`result`
+ * events were renamed: assistant text arrives as a `message` (with a `role` and
+ * `text`), tool calls as `tool_call` (`toolName`/`parameters`), and the terminal
+ * event as `completion` (`finalText`). We map both shapes so the adapter works
+ * across droid versions.
+ */
+interface FactoryDroidsMessageEvent {
+  type: "message";
+  role: "assistant" | "user";
+  text: string;
+  id?: string;
+  session_id?: string;
+}
+interface FactoryDroidsToolCallEvent {
+  type: "tool_call";
+  toolName: string;
+  parameters?: unknown;
+  toolId?: string;
+  id?: string;
+  session_id?: string;
+}
+interface FactoryDroidsCompletionEvent {
+  type: "completion";
+  finalText?: string;
+  numTurns?: number;
+  durationMs?: number;
+  session_id?: string;
+  usage?: {
+    input_tokens?: number;
+    output_tokens?: number;
+    cache_read_input_tokens?: number;
+    cache_creation_input_tokens?: number;
+  };
+}
+type FactoryDroidsEvent = FactoryDroidsAssistantEvent | FactoryDroidsThinkingEvent | FactoryDroidsToolUseEvent | FactoryDroidsToolResultEvent | FactoryDroidsSystemEvent | FactoryDroidsErrorEvent | FactoryDroidsResultEvent | FactoryDroidsMessageEvent | FactoryDroidsToolCallEvent | FactoryDroidsCompletionEvent;
+/**
+ * Configuration for the Factory Droids provider.
+ * Extends the shared CliProviderConfig with Factory Droids-specific options.
+ */
+interface FactoryDroidsConfig extends CliProviderConfig {
+  /** Path to the droid CLI (default: "droid") */
+  cliPath?: string;
+  /** Default model to use */
+  model?: string;
+  /**
+   * Autonomy level passed to `droid exec --auto`. droid only accepts
+   * low|medium|high; full bypass is `bypassPermissions` (→ `--skip-permissions-unsafe`),
+   * NOT an autonomy level.
+   */
+  autonomyLevel?: "low" | "medium" | "high";
+  /** Extra flags to pass to the CLI */
+  extraFlags?: string[];
+  /** API key for Factory Droids (can also use FACTORY_API_KEY env var) */
+  apiKey?: string;
+  /**
+   * Route clarifying questions through a per-execution loopback MCP server.
+   * Factory Droids does not advertise plan support because it cannot enforce
+   * a terminal plan-before-execute boundary. Permission remains governed by
+   * droid's autonomy flags. Default: false.
+   */
+  interactions?: CliProviderConfig["interactions"];
+}
+//#endregion
+//#region src/adapters/factory-droids/adapter.d.ts
+/**
+ * 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.
+ */
+declare class FactoryDroidsProviderAdapter extends CliProviderAdapterBase<FactoryDroidsConfig, FactoryDroidsEvent> {
+  readonly provider = "factory-droids";
+  protected readonly 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`.
+   */
+  private activeInteractions?;
+  private configuredInteractionKinds;
+  getCapabilities(): BackendCapabilities;
+  /**
+   * 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.
+   */
+  execute(input: AgentExecutionInput, services: SdkHostServices, onEvent?: (event: StreamEvent) => void): Promise<AgentExecutionResult>;
+  respondToInteraction(response: InteractionResponse): Promise<void>;
+  /**
+   * Initialize the adapter with API key validation.
+   * Factory Droids requires an API key to function.
+   */
+  protected afterInitialize(config: ProviderConfig): Promise<void>;
+  protected buildExecArgs(params: {
+    message: string;
+    config: FactoryDroidsConfig;
+    model?: string;
+    sessionId?: string;
+    workspaceRoot: string;
+    systemPrompt?: string;
+  }): CliExecArgs;
+  protected buildExecEnv(config: FactoryDroidsConfig): Record<string, string | undefined>;
+  protected createEventParser(state: ExecutionState, onEvent?: (event: StreamEvent) => void): StreamParserConfig<FactoryDroidsEvent>;
+  protected buildMcpAddArgs(name: string, config: McpConfig): string[];
+}
+//#endregion
+//#region src/adapters/factory-droids/event-mapper.d.ts
+/**
+ * Type guard for Factory Droids events.
+ */
+declare function isFactoryDroidsEvent(value: unknown): value is FactoryDroidsEvent;
+/**
+ * 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
+ */
+declare function mapFactoryDroidsEvent(event: FactoryDroidsEvent, state: ExecutionState): StreamEvent[];
+//#endregion
+export { type FactoryDroidsAssistantEvent, type FactoryDroidsConfig, type FactoryDroidsErrorEvent, type FactoryDroidsEvent, FactoryDroidsProviderAdapter, type FactoryDroidsResultEvent, type FactoryDroidsSystemEvent, type FactoryDroidsThinkingEvent, type FactoryDroidsToolResultEvent, type FactoryDroidsToolUseEvent, isFactoryDroidsEvent, mapFactoryDroidsEvent };
+//# sourceMappingURL=index.d.mts.map