shariq-pi-extensions 0.1.0

package/extensions/factory-provider/factory/responses.ts

@@ -0,0 +1,331 @@
+import { clampThinkingLevel } from "@earendil-works/pi-ai";
+import {
+  createAssistantMessageEventStream,
+  stream,
+  streamSimple,
+} from "@earendil-works/pi-ai/compat";
+import { factoryApiForModel } from "./models.ts";
+
+export const FACTORY_SYSTEM_MARKER = "You are Droid, an AI software engineering agent built by Factory.";
+
+const BLOCKED_PI_PROMPT_PHRASES: Array<[RegExp, string]> = [
+  [
+    /You are an expert coding assistant operating inside pi, a coding agent harness\./g,
+    "You are an expert coding assistant running in Pi.",
+  ],
+];
+
+function sanitizeText(text: string) {
+  let sanitized = text;
+  for (const [pattern, replacement] of BLOCKED_PI_PROMPT_PHRASES) sanitized = sanitized.replace(pattern, replacement);
+  return sanitized;
+}
+
+function sanitizeContent(content: any): any {
+  if (typeof content === "string") return sanitizeText(content);
+  if (Array.isArray(content)) return content.map(sanitizeContent);
+  if (content && typeof content === "object") {
+    if (typeof content.text === "string") return { ...content, text: sanitizeText(content.text) };
+    return content;
+  }
+  return content;
+}
+
+export function sanitizeFactoryContext(context: any) {
+  const messages = Array.isArray(context?.messages)
+    ? context.messages.map((message: any) => {
+        if (message?.role !== "system" && message?.role !== "developer") return message;
+        return { ...message, content: sanitizeContent(message.content) };
+      })
+    : context?.messages;
+  const sanitizedPrompt = typeof context?.systemPrompt === "string" ? sanitizeText(context.systemPrompt) : "";
+  const systemPrompt = sanitizedPrompt.startsWith(FACTORY_SYSTEM_MARKER)
+    ? sanitizedPrompt
+    : `${FACTORY_SYSTEM_MARKER}${sanitizedPrompt ? `\n\n${sanitizedPrompt}` : ""}`;
+  return { ...context, systemPrompt, messages };
+}
+
+export function resolvedFactoryReasoning(model: any, reasoning: string | undefined) {
+  if (!reasoning) return undefined;
+  const clamped = clampThinkingLevel(model, reasoning as any);
+  const mapped = model.thinkingLevelMap?.[clamped];
+  return typeof mapped === "string" ? mapped : clamped;
+}
+
+function optionsWithDirectReasoningEffort(options: any, model: any) {
+  const reasoningEffort = resolvedFactoryReasoning(model, options?.reasoning);
+  return {
+    ...options,
+    reasoningEffort: reasoningEffort && reasoningEffort !== "off" && reasoningEffort !== "none" ? reasoningEffort : undefined,
+  };
+}
+
+function optionsWithFactoryResponsesPayload(options: any, model: any) {
+  const apiProvider = Object.entries(model.headers || {}).find(([name]) => name.toLowerCase() === "x-api-provider")?.[1];
+  return {
+    ...options,
+    onPayload: async (payload: any, payloadModel: any) => {
+      const input = Array.isArray(payload?.input) ? [...payload.input] : [];
+      const first = input[0];
+      if (
+        first &&
+        (first.role === "system" || first.role === "developer") &&
+        typeof first.content === "string" &&
+        first.content.includes(FACTORY_SYSTEM_MARKER)
+      ) {
+        payload.instructions = first.content;
+        input.shift();
+        payload.input = input;
+      }
+      payload.parallel_tool_calls ??= true;
+      if (apiProvider === "xai" && payload.reasoning && typeof payload.reasoning === "object") {
+        delete payload.reasoning.summary;
+      }
+      return options?.onPayload ? options.onPayload(payload, payloadModel) : payload;
+    },
+  };
+}
+
+function messageText(content: any): string {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content.filter((part) => part?.type === "text" && typeof part.text === "string").map((part) => part.text).join("\n");
+}
+
+function convertFactoryGeminiMessages(context: any): any[] {
+  const contents: any[] = [];
+  for (const message of context.messages ?? []) {
+    if (message.role === "system" || message.role === "developer") continue;
+    if (message.role === "user") {
+      const blocks = typeof message.content === "string" ? [{ type: "text", text: message.content }] : message.content ?? [];
+      const parts = blocks.flatMap((part: any) => {
+        if (part?.type === "text" && typeof part.text === "string") return [{ text: part.text }];
+        if (part?.type === "image" && typeof part.data === "string") {
+          return [{ inlineData: { mimeType: part.mimeType ?? "image/png", data: part.data } }];
+        }
+        return [];
+      });
+      if (parts.length > 0) contents.push({ role: "user", parts });
+      continue;
+    }
+    if (message.role === "assistant") {
+      const parts = (message.content ?? []).flatMap((part: any) => {
+        if (part?.type === "text" && typeof part.text === "string") return [{ text: part.text }];
+        if (part?.type === "thinking" && typeof part.thinking === "string") return [{ text: part.thinking, thought: true }];
+        if (part?.type === "toolCall") {
+          return [{ functionCall: { id: part.id, name: part.name, args: part.arguments ?? {} }, ...(part.thoughtSignature ? { thoughtSignature: part.thoughtSignature } : {}) }];
+        }
+        return [];
+      });
+      if (parts.length > 0) contents.push({ role: "model", parts });
+      continue;
+    }
+    if (message.role === "toolResult") {
+      const responseText = messageText(message.content);
+      const part = {
+        functionResponse: {
+          id: message.toolCallId,
+          name: message.toolName,
+          response: message.isError ? { error: responseText } : { output: responseText },
+        },
+      };
+      const previous = contents.at(-1);
+      if (previous?.role === "user" && previous.parts?.some((item: any) => item.functionResponse)) previous.parts.push(part);
+      else contents.push({ role: "user", parts: [part] });
+    }
+  }
+  return contents;
+}
+
+function factoryGeminiTools(tools: any[] | undefined) {
+  if (!tools?.length) return undefined;
+  return [{
+    functionDeclarations: tools.map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      parametersJsonSchema: tool.parameters,
+    })),
+  }];
+}
+
+async function forEachFactoryGeminiEvent(response: Response, visit: (event: any) => void) {
+  const contentType = response.headers.get("content-type") ?? "";
+  if (!response.body || !contentType.includes("text/event-stream")) {
+    const parsed = JSON.parse(await response.text());
+    for (const event of Array.isArray(parsed) ? parsed : [parsed]) visit(event);
+    return;
+  }
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let pending = "";
+  while (true) {
+    const { done, value } = await reader.read();
+    pending += decoder.decode(value, { stream: !done });
+    const lines = pending.split(/\r?\n/);
+    pending = done ? "" : lines.pop() ?? "";
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed.startsWith("data:")) continue;
+      const data = trimmed.slice(5).trim();
+      if (data && data !== "[DONE]") visit(JSON.parse(data));
+    }
+    if (done) break;
+  }
+  const trailing = pending.trim();
+  if (trailing.startsWith("data:")) {
+    const data = trailing.slice(5).trim();
+    if (data && data !== "[DONE]") visit(JSON.parse(data));
+  }
+}
+
+let factoryGeminiToolCallCounter = 0;
+
+export function streamFactoryGemini(model: any, context: any, options?: any) {
+  const eventStream = createAssistantMessageEventStream();
+  (async () => {
+    const output: any = {
+      role: "assistant",
+      content: [],
+      api: model.api,
+      provider: model.provider,
+      model: model.id,
+      usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, reasoning: 0, totalTokens: 0, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } },
+      stopReason: "pending",
+      timestamp: Date.now(),
+    };
+    let currentBlock: any;
+    const finishBlock = () => {
+      if (!currentBlock) return;
+      const contentIndex = output.content.indexOf(currentBlock);
+      if (currentBlock.type === "thinking") {
+        eventStream.push({ type: "thinking_end", contentIndex, content: currentBlock.thinking, partial: output });
+      } else {
+        eventStream.push({ type: "text_end", contentIndex, content: currentBlock.text, partial: output });
+      }
+      currentBlock = undefined;
+    };
+    try {
+      const reasoningEffort = resolvedFactoryReasoning(model, options?.reasoning);
+      let payload: any = {
+        model: model.id,
+        contents: convertFactoryGeminiMessages(context),
+        ...(context.systemPrompt ? { systemInstruction: { parts: [{ text: context.systemPrompt }] } } : {}),
+        ...(context.tools?.length ? { tools: factoryGeminiTools(context.tools) } : {}),
+        generationConfig: {
+          temperature: options?.temperature ?? 1,
+          topP: 0.95,
+          topK: 64,
+          ...(reasoningEffort ? { thinkingConfig: { includeThoughts: true, thinkingLevel: reasoningEffort.toUpperCase() } } : {}),
+          ...(options?.maxTokens !== undefined ? { maxOutputTokens: options.maxTokens } : {}),
+        },
+      };
+      const transformed = await options?.onPayload?.(payload, model);
+      if (transformed !== undefined) payload = transformed;
+      const baseUrl = String(model.baseUrl || "https://api.factory.ai/api/llm/g/v1").replace(/\/$/, "");
+      const response = await fetch(`${baseUrl}/generate`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...(options?.headers || {}) },
+        body: JSON.stringify(payload),
+        signal: options?.signal,
+      });
+      if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
+      eventStream.push({ type: "start", partial: output });
+      await forEachFactoryGeminiEvent(response, (chunk) => {
+        const candidate = chunk?.candidates?.[0];
+        for (const part of candidate?.content?.parts ?? []) {
+          if (typeof part.text === "string") {
+            const blockType = part.thought === true ? "thinking" : "text";
+            if (!currentBlock || currentBlock.type !== blockType) {
+              finishBlock();
+              currentBlock = blockType === "thinking"
+                ? { type: "thinking", thinking: "", thinkingSignature: part.thoughtSignature }
+                : { type: "text", text: "", textSignature: part.thoughtSignature };
+              output.content.push(currentBlock);
+              eventStream.push({ type: `${blockType}_start`, contentIndex: output.content.length - 1, partial: output });
+            }
+            if (blockType === "thinking") {
+              currentBlock.thinking += part.text;
+              currentBlock.thinkingSignature ||= part.thoughtSignature;
+              eventStream.push({ type: "thinking_delta", contentIndex: output.content.length - 1, delta: part.text, partial: output });
+            } else {
+              currentBlock.text += part.text;
+              currentBlock.textSignature ||= part.thoughtSignature;
+              eventStream.push({ type: "text_delta", contentIndex: output.content.length - 1, delta: part.text, partial: output });
+            }
+          }
+          if (part.functionCall) {
+            finishBlock();
+            const toolCall = {
+              type: "toolCall" as const,
+              id: part.functionCall.id || `${part.functionCall.name}_${Date.now()}_${++factoryGeminiToolCallCounter}`,
+              name: part.functionCall.name || "",
+              arguments: part.functionCall.args ?? {},
+              ...(part.thoughtSignature ? { thoughtSignature: part.thoughtSignature } : {}),
+            };
+            output.content.push(toolCall);
+            const contentIndex = output.content.length - 1;
+            eventStream.push({ type: "toolcall_start", contentIndex, partial: output });
+            eventStream.push({ type: "toolcall_delta", contentIndex, delta: JSON.stringify(toolCall.arguments), partial: output });
+            eventStream.push({ type: "toolcall_end", contentIndex, toolCall, partial: output });
+          }
+        }
+        if (candidate?.finishReason) {
+          output.rawStopReason = candidate.finishReason;
+          output.stopReason = candidate.finishReason === "MAX_TOKENS" ? "length" : candidate.finishReason === "STOP" ? "stop" : "error";
+        }
+        if (chunk?.usageMetadata) {
+          const usage = chunk.usageMetadata;
+          output.usage = {
+            input: (usage.promptTokenCount ?? 0) - (usage.cachedContentTokenCount ?? 0),
+            output: (usage.candidatesTokenCount ?? 0) + (usage.thoughtsTokenCount ?? 0),
+            cacheRead: usage.cachedContentTokenCount ?? 0,
+            cacheWrite: 0,
+            reasoning: usage.thoughtsTokenCount ?? 0,
+            totalTokens: usage.totalTokenCount ?? 0,
+            cost: output.usage.cost,
+          };
+        }
+      });
+      finishBlock();
+      if (options?.signal?.aborted) throw new Error("Request was aborted");
+      if (output.content.some((part: any) => part.type === "toolCall") && output.stopReason === "stop") output.stopReason = "toolUse";
+      if (output.stopReason === "pending") throw new Error("Factory Gemini stream ended without a finish reason");
+      if (output.stopReason === "error") throw new Error(`Provider stopped with: ${output.rawStopReason ?? "unknown"}`);
+      eventStream.push({ type: "done", reason: output.stopReason, message: output });
+      eventStream.end();
+    } catch (error: any) {
+      output.stopReason = options?.signal?.aborted ? "aborted" : "error";
+      output.errorMessage = error?.message || String(error);
+      eventStream.push({ type: "error", reason: output.stopReason, error: output });
+      eventStream.end();
+    }
+  })();
+  return eventStream;
+}
+
+export function streamSimpleFactoryResponses(model: any, context: any, options?: any) {
+  const api = factoryApiForModel(model.id);
+  const routedModel = { ...model, api };
+  const sanitizedContext = sanitizeFactoryContext(context);
+  switch (api) {
+    case "anthropic-messages": {
+      const reasoningDisabled = options?.reasoning === "off" || options?.reasoning === "none";
+      if (!reasoningDisabled) return streamSimple(routedModel, sanitizedContext, options);
+      return streamSimple(routedModel, sanitizedContext, {
+        ...options,
+        reasoning: undefined,
+        onPayload: async (payload: any, payloadModel: any) => {
+          if (payload?.thinking?.type === "disabled") delete payload.thinking;
+          return options?.onPayload ? options.onPayload(payload, payloadModel) : payload;
+        },
+      });
+    }
+    case "google-generative-ai":
+      return streamFactoryGemini(routedModel, sanitizedContext, options);
+    case "openai-completions":
+      return stream(routedModel, sanitizedContext, optionsWithDirectReasoningEffort(options, routedModel));
+    case "openai-responses":
+    default:
+      return streamSimple(routedModel, sanitizedContext, optionsWithFactoryResponsesPayload(options, routedModel));
+  }
+}

package/extensions/factory-provider/factory/warm-theme.ts

@@ -0,0 +1,53 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+
+type Rgb = readonly [number, number, number];
+
+/**
+ * Warm, high-contrast Factory-only experiment.
+ *
+ * The palette uses distinct page, surface, and focus levels while replacing
+ * blue/cyan with amber, cream, terracotta, olive, and warm charcoal. It never
+ * changes Pi's global theme.
+ */
+export const FACTORY_WARM_PALETTE = {
+  accent: [242, 169, 86],
+  text: [248, 234, 211],
+  muted: [207, 177, 145],
+  dim: [158, 128, 103],
+  success: [216, 194, 122],
+  warning: [239, 145, 87],
+  error: [239, 112, 96],
+  border: [139, 96, 68],
+  borderMuted: [82, 59, 48],
+  borderAccent: [220, 132, 64],
+  selectedBg: [72, 46, 35],
+} satisfies Record<string, Rgb>;
+
+function foreground(color: Rgb, text: string) {
+  return `\x1b[38;2;${color[0]};${color[1]};${color[2]}m${text}\x1b[39m`;
+}
+
+function background(color: Rgb, text: string) {
+  return `\x1b[48;2;${color[0]};${color[1]};${color[2]}m${text}\x1b[49m`;
+}
+
+export function factoryWarmTheme(theme: Theme): Theme {
+  return new Proxy(theme, {
+    get(target, property, receiver) {
+      if (property === "fg") {
+        return (color: Parameters<Theme["fg"]>[0], text: string) => {
+          const rgb = FACTORY_WARM_PALETTE[color as keyof typeof FACTORY_WARM_PALETTE];
+          return rgb ? foreground(rgb, text) : target.fg(color, text);
+        };
+      }
+      if (property === "bg") {
+        return (color: Parameters<Theme["bg"]>[0], text: string) => {
+          const rgb = FACTORY_WARM_PALETTE[color as keyof typeof FACTORY_WARM_PALETTE];
+          return rgb ? background(rgb, text) : target.bg(color, text);
+        };
+      }
+      const value = Reflect.get(target, property, receiver);
+      return typeof value === "function" ? value.bind(target) : value;
+    },
+  });
+}

package/extensions/factory-provider/factory/websocket.ts

@@ -0,0 +1,130 @@
+import WebSocket, { type RawData } from "ws";
+
+const FACTORY_DROID_MARKER = "You are Droid, an AI software engineering agent built by Factory.";
+
+export interface FactoryWebSocketFetchOptions {
+	apiKey: string;
+	assistantMessageId: string;
+	headers: Record<string, string>;
+}
+
+export function factoryResponsesWebSocketUrl(httpUrl: string): string {
+	const url = new URL(httpUrl);
+	url.protocol = url.protocol === "http:" ? "ws:" : "wss:";
+	url.pathname = `${url.pathname.replace(/\/$/, "")}/ws`;
+	return url.toString();
+}
+
+export function prepareFactoryResponsesWebSocketPayload(body: unknown): Record<string, unknown> {
+	if (!body || typeof body !== "object" || Array.isArray(body)) {
+		throw new Error("Factory Responses request body must be a JSON object");
+	}
+
+	const payload = { ...(body as Record<string, unknown>) };
+	const input = Array.isArray(payload.input) ? [...payload.input] : [];
+	const first = input[0];
+	if (first && typeof first === "object" && !Array.isArray(first)) {
+		const message = first as Record<string, unknown>;
+		if (
+			(message.role === "developer" || message.role === "system") &&
+			typeof message.content === "string" &&
+			message.content.includes(FACTORY_DROID_MARKER)
+		) {
+			payload.instructions = message.content;
+			input.shift();
+			payload.input = input;
+		}
+	}
+
+	payload.parallel_tool_calls ??= true;
+	payload.tool_choice ??= "auto";
+	return { type: "response.create", ...payload };
+}
+
+/** Adapt Factory's Responses WebSocket transport to the Fetch/SSE interface used by pi-ai. */
+export function createFactoryResponsesWebSocketFetch(options: FactoryWebSocketFetchOptions): typeof fetch {
+	return (async (input: RequestInfo | URL, init?: RequestInit): Promise<Response> => {
+		const requestUrl = typeof input === "string" || input instanceof URL ? input.toString() : input.url;
+		const bodyText = typeof init?.body === "string" ? init.body : await new Request(input, init).text();
+		const payload = prepareFactoryResponsesWebSocketPayload(JSON.parse(bodyText));
+		payload._factory = { assistantMessageId: options.assistantMessageId };
+		const responseStream = new TransformStream<Uint8Array, Uint8Array>();
+		const writer = responseStream.writable.getWriter();
+		const encoder = new TextEncoder();
+
+		return await new Promise<Response>((resolve, reject) => {
+			let opened = false;
+			let settled = false;
+			const socket = new WebSocket(factoryResponsesWebSocketUrl(requestUrl), {
+				headers: {
+					...options.headers,
+					Authorization: `Bearer ${options.apiKey}`,
+				},
+			});
+
+			const abort = () => {
+				socket.close();
+				void writer.abort(new Error("Factory request was aborted"));
+				if (!settled) {
+					settled = true;
+					reject(new Error("Factory request was aborted"));
+				}
+			};
+			init?.signal?.addEventListener("abort", abort, { once: true });
+
+			socket.once("open", () => {
+				opened = true;
+				settled = true;
+				socket.send(JSON.stringify(payload));
+				resolve(
+					new Response(responseStream.readable, {
+						status: 200,
+						headers: { "content-type": "text/event-stream" },
+					}),
+				);
+			});
+
+			socket.on("message", (data: RawData) => {
+				const text = data.toString();
+				void writer.write(encoder.encode(`data: ${text}\n\n`));
+				try {
+					const event = JSON.parse(text) as { type?: string };
+					if (event.type === "response.completed" || event.type === "response.failed" || event.type === "error") {
+						void writer.close();
+						socket.close();
+					}
+				} catch {
+					// Let pi-ai report malformed provider events through its normal parser.
+				}
+			});
+
+			socket.once("unexpected-response", (_request, response) => {
+				const chunks: Buffer[] = [];
+				response.on("data", (chunk: Buffer) => chunks.push(chunk));
+				response.on("end", () => {
+					settled = true;
+					resolve(
+						new Response(Buffer.concat(chunks), {
+							status: response.statusCode ?? 500,
+							statusText: response.statusMessage,
+							headers: response.headers as HeadersInit,
+						}),
+					);
+				});
+			});
+
+			socket.once("error", (error) => {
+				if (!settled) {
+					settled = true;
+					reject(error);
+				} else if (opened) {
+					void writer.abort(error);
+				}
+			});
+			socket.once("close", () => {
+				init?.signal?.removeEventListener("abort", abort);
+				if (opened) void writer.close().catch(() => undefined);
+			});
+		});
+	}) as typeof fetch;
+}