paseo-prompt-kit 0.5.2

package/server/log.ts

@@ -0,0 +1,20 @@
+const PREFIX = "[prompt-kit]";
+
+/**
+ * Plugin stdout is captured by the daemon and shown by `paseo plugin logs`.
+ * Only non-content fields are logged: prompts and rewritten text never reach it.
+ */
+export const pluginLog = {
+  info(fields: Record<string, string | number | null>, message: string): void {
+    console.log(`${PREFIX} ${message} ${format(fields)}`);
+  },
+  error(fields: Record<string, string | number | null>, message: string): void {
+    console.error(`${PREFIX} ${message} ${format(fields)}`);
+  },
+};
+
+function format(fields: Record<string, string | number | null>): string {
+  return Object.entries(fields)
+    .map(([key, value]) => `${key}=${value === null ? "-" : String(value)}`)
+    .join(" ");
+}

package/server/model-resolver/provider-catalog.ts

@@ -0,0 +1,37 @@
+import type { ProviderCatalogOutput } from "../../shared/rpc.js";
+import type { PaseoApi } from "../paseo-types.js";
+
+export type ProviderCatalog = ProviderCatalogOutput["providers"];
+export type CatalogProvider = ProviderCatalog[number];
+export type CatalogModel = CatalogProvider["models"][number];
+
+/**
+ * Providers are reported available only when the daemon's own availability probe
+ * says so. A provider missing from that probe is treated as unavailable.
+ */
+export async function readProviderCatalog(paseo: PaseoApi, cwd?: string): Promise<ProviderCatalog> {
+  const options = cwd === undefined ? undefined : { cwd };
+  const [snapshot, availability] = await Promise.all([
+    paseo.providers.snapshot(options),
+    paseo.providers.listAvailable(),
+  ]);
+  const available = new Map(
+    availability.providers.map((entry) => [entry.provider, entry.available]),
+  );
+  return snapshot.entries
+    .map((entry) => ({
+      provider: entry.provider,
+      label: entry.label ?? entry.provider,
+      available: available.get(entry.provider) === true,
+      models: (entry.models ?? []).map((model) => ({
+        id: model.id,
+        label: model.label,
+        thinkingOptions: (model.thinkingOptions ?? []).map((option) => ({
+          id: option.id,
+          label: option.label,
+        })),
+        defaultThinkingOptionId: model.defaultThinkingOptionId ?? null,
+      })),
+    }))
+    .sort((left, right) => left.provider.localeCompare(right.provider));
+}

package/server/model-resolver/resolver.ts

@@ -0,0 +1,196 @@
+import type { ApiEndpoint } from "../../shared/api-protocol.js";
+import type { RewriteError } from "../../shared/rpc.js";
+import type { PromptKitSettings } from "../../shared/settings.js";
+import type { PaseoApi } from "../paseo-types.js";
+import { resolveFamily, type CliFamily } from "../transports/cli/family.js";
+import { readProviderCatalog } from "./provider-catalog.js";
+
+/** Resolves provider/model/thinking and transport for one request. Runs nothing. */
+
+export interface ResolvedModel {
+  readonly provider: string;
+  readonly model: string | null;
+  readonly thinkingOptionId: string | null;
+}
+
+export type ResolvedTarget =
+  | { ok: true; via: "cli"; family: CliFamily; model: ResolvedModel; cwd: string }
+  | { ok: true; via: "api"; endpoint: ApiEndpoint; model: string; reported: ResolvedModel }
+  | { ok: false; error: RewriteError };
+
+/** What the resolver needs to know about the agent whose pill was pressed. */
+interface AgentModelSnapshot {
+  readonly provider: string;
+  readonly model: string | null;
+  readonly thinkingOptionId: string | null;
+  readonly cwd: string;
+}
+
+/** `provider/model` selector → provider. */
+function providerOf(selector: string): string {
+  const separator = selector.indexOf("/");
+  return separator === -1 ? selector : selector.slice(0, separator);
+}
+
+/** Runtime model first, like the host's `resolvePreferredModelId`. */
+function runtimeModel(agent: { runtimeInfo?: { model?: string | null } | null }): string | null {
+  const model = agent.runtimeInfo?.model;
+  return typeof model === "string" && model.trim() !== "" ? model : null;
+}
+
+/** Reads the agent without requiring a CLI family; only the current-CLI path needs one. */
+async function readAgent(paseo: PaseoApi, agentId: string): Promise<AgentModelSnapshot | null> {
+  const refreshed = await paseo.agents.ref(agentId).refresh();
+  if (!refreshed) return null;
+  const agent = refreshed.agent;
+  return {
+    provider: providerOf(agent.runtimeInfo?.provider ?? agent.provider),
+    model: runtimeModel(agent) ?? agent.model,
+    // `effectiveThinkingOptionId` is the host's own resolution: the runtime
+    // option when the session reported one, otherwise the configured option.
+    thinkingOptionId: agent.effectiveThinkingOptionId ?? agent.thinkingOptionId ?? null,
+    cwd: agent.cwd,
+  };
+}
+
+function invalidSelection(message: string): { ok: false; error: RewriteError } {
+  return { ok: false, error: { code: "invalid_selection", message } };
+}
+
+function invalidModel(message: string): { ok: false; error: RewriteError } {
+  return { ok: false, error: { code: "invalid_model", message } };
+}
+
+function unsupported(provider: string): { ok: false; error: RewriteError } {
+  return {
+    ok: false,
+    error: {
+      code: "unsupported_provider",
+      message: `No rewrite CLI is configured for provider "${provider}".`,
+    },
+  };
+}
+
+const AGENT_GONE = "The current agent is no longer available.";
+const NO_AGENT_YET =
+  "This Composer has no agent yet, so there is no current model to use. Choose a dedicated model or Direct API in PromptKit settings, or send the first message and use the PromptKit pill.";
+
+/** Path 1: the agent's own provider CLI, with the model the Composer shows. */
+function resolveCurrentCli(agent: AgentModelSnapshot, settings: PromptKitSettings): ResolvedTarget {
+  const family = resolveFamily(agent.provider, settings.providerCli);
+  if (family === null) return unsupported(agent.provider);
+  if (agent.model === null || agent.model === "") {
+    return invalidSelection(`The agent has no model selected for provider "${agent.provider}".`);
+  }
+  return {
+    ok: true,
+    via: "cli",
+    family,
+    model: { provider: agent.provider, model: agent.model, thinkingOptionId: agent.thinkingOptionId },
+    cwd: agent.cwd,
+  };
+}
+
+/** Path 2: dedicated provider CLI, checked against the live catalog. */
+async function resolveDedicatedCli(
+  paseo: PaseoApi,
+  settings: PromptKitSettings,
+  cwd: string | undefined,
+): Promise<ResolvedTarget> {
+  const provider = settings.dedicatedProvider;
+  const model = settings.dedicatedModel;
+  if (provider === null || model === null) {
+    return invalidSelection("No dedicated provider and model are selected in PromptKit settings.");
+  }
+  const family = resolveFamily(provider, settings.providerCli);
+  if (family === null) return unsupported(provider);
+
+  let catalog: Awaited<ReturnType<typeof readProviderCatalog>>;
+  try {
+    catalog = await readProviderCatalog(paseo, cwd);
+  } catch (error) {
+    return invalidModel(
+      `Could not read the provider catalog: ${error instanceof Error ? error.message : String(error)}`,
+    );
+  }
+  const entry = catalog.find((candidate) => candidate.provider === provider);
+  if (!entry || !entry.available) return invalidModel(`Provider is unavailable: ${provider}`);
+  const selected = entry.models.find((candidate) => candidate.id === model);
+  if (!selected) return invalidModel(`Model is unavailable: ${provider}/${model}`);
+  const thinking = settings.dedicatedThinkingOptionId;
+  if (thinking !== null && !selected.thinkingOptions.some((option) => option.id === thinking)) {
+    return invalidModel(`Thinking option is unavailable: ${provider}/${model} ${thinking}`);
+  }
+  return {
+    ok: true,
+    via: "cli",
+    family,
+    model: { provider, model, thinkingOptionId: thinking },
+    cwd: cwd ?? "",
+  };
+}
+
+/** Path 3: API endpoint. A mapped provider sends its agent's model; otherwise the selected endpoint and model. `modelMode` is not read. */
+function resolveApi(agent: AgentModelSnapshot | null, settings: PromptKitSettings): ResolvedTarget {
+  const mappedEndpointId = agent === null ? undefined : settings.apiEndpointByProvider[agent.provider];
+  const viaProviderMapping = mappedEndpointId !== undefined;
+
+  const endpointId = viaProviderMapping ? mappedEndpointId : settings.apiEndpointId;
+  if (endpointId === null) {
+    return invalidSelection(
+      agent === null
+        ? "No API endpoint is selected in PromptKit settings."
+        : `No API endpoint is selected in PromptKit settings, and provider "${agent.provider}" is not mapped to one.`,
+    );
+  }
+  const endpoint = settings.apiEndpoints.find((candidate) => candidate.id === endpointId);
+  if (endpoint === undefined) {
+    return {
+      ok: false,
+      error: {
+        code: "api_endpoint_unknown",
+        message: `No API endpoint is configured with the id "${endpointId}".`,
+      },
+    };
+  }
+
+  const model = viaProviderMapping && agent !== null ? agent.model : settings.apiModel;
+  if (model === null || model.trim() === "") {
+    return invalidSelection(
+      viaProviderMapping && agent !== null
+        ? `The agent has no model selected for provider "${agent.provider}".`
+        : "No API model is selected in PromptKit settings.",
+    );
+  }
+  if (endpoint.models.length > 0 && !endpoint.models.includes(model)) {
+    return invalidModel(`Model is unavailable on endpoint "${endpoint.id}": ${model}`);
+  }
+
+  return {
+    ok: true,
+    via: "api",
+    endpoint,
+    model,
+    reported: { provider: endpoint.id, model, thinkingOptionId: null },
+  };
+}
+
+export async function resolveTarget(
+  paseo: PaseoApi,
+  agentId: string | null,
+  settings: PromptKitSettings,
+): Promise<ResolvedTarget> {
+  // Draft Composer: only agent-dependent paths refuse.
+  if (agentId === null) {
+    if (settings.transport === "api") return resolveApi(null, settings);
+    if (settings.modelMode !== "dedicated") return invalidSelection(NO_AGENT_YET);
+    return resolveDedicatedCli(paseo, settings, undefined);
+  }
+
+  const agent = await readAgent(paseo, agentId);
+  if (agent === null) return invalidSelection(AGENT_GONE);
+
+  if (settings.transport === "api") return resolveApi(agent, settings);
+  if (settings.modelMode === "dedicated") return resolveDedicatedCli(paseo, settings, agent.cwd);
+  return resolveCurrentCli(agent, settings);
+}

package/server/paseo-types.ts

@@ -0,0 +1,13 @@
+import type { PluginHandlerContext } from "@getpaseo/plugin/server";
+
+/**
+ * The daemon bundles the server entry from a managed checkout that has no
+ * `node_modules`; only the host SDK specifiers resolve there, and the client
+ * package is not one of them. The Paseo types are therefore derived from the
+ * SDK the host passes into a handler, never imported from the client package.
+ */
+export type PaseoApi = PluginHandlerContext["paseo"];
+
+export type PaseoAgentHandle = Awaited<
+  ReturnType<ReturnType<PaseoApi["workspaces"]["ref"]>["agents"]["create"]>
+>;

package/server/rewrite-engine/engine.ts

@@ -0,0 +1,88 @@
+import type { RewriteOutput } from "../../shared/rpc.js";
+import type { PromptKitSettings } from "../../shared/settings.js";
+import { resolveTarget } from "../model-resolver/resolver.js";
+import type { PaseoApi } from "../paseo-types.js";
+import { runApiRewrite } from "../transports/api/runner.js";
+import type { CliSpawner } from "../transports/cli/process.js";
+import { runCliRewrite } from "../transports/cli/runner.js";
+import { validateRewriteOutput } from "./output-validator.js";
+
+export interface RewriteRequest {
+  /** Null for a Composer that has no agent yet. */
+  agentId: string | null;
+  workspaceId: string;
+  systemPrompt: string;
+  /** The user's own prompt; protected-literal validation runs against this, not the wrapper. */
+  originalPrompt: string;
+  taskPrompt: string;
+}
+
+export interface RewriteDependencies {
+  settings: PromptKitSettings;
+  /** Overrides the request timeout; tests use it to exercise the timeout path. */
+  timeoutMs?: number;
+  /** Test seam: replaces the process spawner under the CLI runner. */
+  spawn?: CliSpawner;
+  /** Test seam: replaces the HTTP call under the API runner. */
+  fetch?: typeof globalThis.fetch;
+  /** Test seam: replaces the environment an API key is read from. */
+  env?: NodeJS.ProcessEnv;
+}
+
+/** resolve target → run transport → validate. Every failure is a typed error. */
+export async function runRewrite(
+  paseo: PaseoApi,
+  request: RewriteRequest,
+  dependencies: RewriteDependencies,
+): Promise<RewriteOutput> {
+  const startedAt = Date.now();
+  const settings = dependencies.settings;
+  const timeoutMs = dependencies.timeoutMs ?? settings.timeoutMs;
+
+  const target = await resolveTarget(paseo, request.agentId, settings);
+  if (!target.ok) return { status: "error", error: target.error };
+
+  const generated =
+    target.via === "api"
+      ? await runApiRewrite(
+          {
+            endpoint: target.endpoint,
+            model: target.model,
+            systemPrompt: request.systemPrompt,
+            taskPrompt: request.taskPrompt,
+            timeoutMs,
+            secretsDir: settings.secretsDir,
+          },
+          {
+            ...(dependencies.fetch === undefined ? {} : { fetch: dependencies.fetch }),
+            ...(dependencies.env === undefined ? {} : { env: dependencies.env }),
+          },
+        )
+      : await runCliRewrite(
+          {
+            family: target.family,
+            model: target.model.model ?? "",
+            thinkingOptionId: target.model.thinkingOptionId,
+            systemPrompt: request.systemPrompt,
+            taskPrompt: request.taskPrompt,
+            timeoutMs,
+          },
+          dependencies.spawn === undefined ? {} : { spawn: dependencies.spawn },
+        );
+  if (!generated.ok) {
+    return { status: "error", error: { code: generated.code, message: generated.message } };
+  }
+
+  const validated = validateRewriteOutput({
+    originalPrompt: request.originalPrompt,
+    output: generated.text,
+  });
+  if (!validated.ok) return { status: "error", error: validated.error };
+
+  return {
+    status: "ok",
+    rewrittenPrompt: validated.text,
+    model: target.via === "api" ? target.reported : target.model,
+    durationMs: Date.now() - startedAt,
+  };
+}

package/server/rewrite-engine/handler.ts

@@ -0,0 +1,94 @@
+import type { PluginHandlerContext } from "@getpaseo/plugin/server";
+import { buildTaskPrompt } from "../../shared/action-registry/wrapper.js";
+import { resolveAction } from "../../shared/action-registry/registry.js";
+import { buildSystemPrompt } from "../../shared/action-registry/rewrite-contract.js";
+import { resolveLanguage } from "../../shared/language-registry/registry.js";
+import type { RewriteInput, RewriteOutput } from "../../shared/rpc.js";
+import type { CliSpawner } from "../transports/cli/process.js";
+import { pluginLog } from "../log.js";
+import { runRewrite } from "./engine.js";
+
+export interface RewriteHandlerDependencies {
+  /** Test seam: replaces the CLI spawner underneath the rewrite engine. */
+  spawn?: CliSpawner;
+  /** Test seam: replaces the HTTP call underneath the API runner. */
+  fetch?: typeof globalThis.fetch;
+  /** Test seam: replaces the environment an API key is read from. */
+  env?: NodeJS.ProcessEnv;
+}
+
+/**
+ * Builds the `prompt-kit.rewrite` handler.
+ *
+ * It owns one job: turn an RPC input into a `runRewrite` call and log the
+ * outcome without ever writing prompt or answer text. The spawner is a
+ * parameter rather than a module global so a test can drive the handler without
+ * launching a real CLI.
+ */
+export function createRewriteHandler(dependencies: RewriteHandlerDependencies = {}) {
+  return async function handleRewrite(
+    input: RewriteInput,
+    { paseo }: PluginHandlerContext,
+  ): Promise<RewriteOutput> {
+    const action = resolveAction(input.actionId, input.settings.customActions);
+    if (action === null) {
+      pluginLog.error({ action: input.actionId }, "rewrite refused: unknown action");
+      return {
+        status: "error",
+        error: {
+          code: "unknown_action",
+          message: `No action pack provides "${input.actionId}".`,
+        },
+      };
+    }
+
+    const language = resolveLanguage(input.settings.outputLanguage);
+    if (language === undefined) {
+      pluginLog.error({ language: input.settings.outputLanguage }, "rewrite refused: unknown language");
+      return {
+        status: "error",
+        error: {
+          code: "invalid_selection",
+          message: `No output language is loaded with the id "${input.settings.outputLanguage}".`,
+        },
+      };
+    }
+
+    pluginLog.info(
+      { action: input.actionId, agentId: input.agentId, language: input.settings.outputLanguage },
+      "rewrite start",
+    );
+
+    const output = await runRewrite(
+      paseo,
+      {
+        agentId: input.agentId,
+        workspaceId: input.workspaceId,
+        systemPrompt: buildSystemPrompt(action),
+        originalPrompt: input.originalPrompt,
+        taskPrompt: buildTaskPrompt(action, input.originalPrompt, language?.instruction ?? null),
+      },
+      {
+        settings: input.settings,
+        ...(dependencies.spawn === undefined ? {} : { spawn: dependencies.spawn }),
+        ...(dependencies.fetch === undefined ? {} : { fetch: dependencies.fetch }),
+        ...(dependencies.env === undefined ? {} : { env: dependencies.env }),
+      },
+    );
+
+    if (output.status === "ok") {
+      pluginLog.info(
+        {
+          action: input.actionId,
+          provider: output.model.provider,
+          model: output.model.model,
+          durationMs: output.durationMs,
+        },
+        "rewrite success",
+      );
+    } else {
+      pluginLog.error({ action: input.actionId, code: output.error.code }, "rewrite failed");
+    }
+    return output;
+  };
+}

package/server/rewrite-engine/output-validator.ts

@@ -0,0 +1,130 @@
+import type { RewriteError } from "../../shared/rpc.js";
+import { findMissingProtectedLiterals } from "../../shared/protected-literals.js";
+
+export type OutputValidation =
+  | { ok: true; text: string }
+  | { ok: false; error: RewriteError };
+
+/** Plan §19: a rewrite far longer than the request is a specification, not a rewrite. */
+const MAX_OUTPUT_CHARS = 20_000;
+
+const FENCE = /```/g;
+
+/**
+ * Only unambiguous meta openers. A rewritten prompt may legitimately start with
+ * "This is broken" or "Output the result", so the vocabulary stays narrow.
+ */
+const META_PREFACE =
+  /^(?:sure[,!.:]|certainly[,!.:]|of course[,!.:]|here(?:'s| is) (?:the |your )?(?:rewritten|improved|enhanced|optimized|revised) (?:prompt|version)|below is (?:the |your )?(?:rewritten|improved|enhanced|optimized|revised) (?:prompt|version)|the (?:rewritten|improved|enhanced|optimized|revised) (?:prompt|version) is[:.]?$|rewritten prompt:|improved prompt:)/i;
+
+const REFUSAL =
+  /^(?:i (?:cannot|can't|won't|will not|am unable|am not able)|i'm sorry|sorry[,.]|as an ai|unfortunately)/i;
+
+/**
+ * Output that talks about the prompt instead of rewriting it. An injection prompt is
+ * exactly the case where a model is tempted to answer with this commentary rather than
+ * the rewrite, so the first line is checked against the meta shapes.
+ */
+const COMMENTARY =
+  /^(?:this (?:prompt|input|request|message) (?:is|looks like|appears to be|contains)|the (?:text|prompt|input|message) (?:below|above) (?:is|contains)|treat (?:this|it) as (?:untrusted|data)|it (?:is|looks like|appears to be) (?:a )?(?:prompt[- ]?injection|injection attempt)|(?:the )?(?:prompt|input)[- ]injection (?:attempt|detected)|i (?:notice|see|detect)|not a legitimate coding task|no action (?:is|was) taken)/i;
+
+function countFences(text: string): number {
+  return (text.match(FENCE) ?? []).length;
+}
+
+/** True when the whole answer is one fenced block, the wrapper the prompt forbids. */
+function isFullMarkdownEnvelope(text: string): boolean {
+  const trimmed = text.trim();
+  return trimmed.startsWith("```") && trimmed.endsWith("```") && countFences(trimmed) === 2;
+}
+
+function nonEmptyLines(text: string): string[] {
+  return text
+    .split("\n")
+    .map((line) => line.trim())
+    .filter((line) => line !== "");
+}
+
+function wordCount(text: string): number {
+  return text.split(/\s+/).filter(Boolean).length;
+}
+
+/** Literals can be whole code blocks; the message needs only enough to recognise them. */
+function clip(value: string, max = 60): string {
+  const flat = value.replace(/\s+/g, " ").trim();
+  return flat.length <= max ? flat : `${flat.slice(0, max - 1)}…`;
+}
+
+function fail(code: RewriteError["code"], message: string): OutputValidation {
+  return { ok: false, error: { code, message } };
+}
+
+/**
+ * Accepts only text that is the rewritten prompt itself: non-empty, fence-balanced,
+ * free of preface/envelope/refusal, and carrying every protected literal of the
+ * original. A rejected output never becomes a replacement text.
+ */
+export function validateRewriteOutput(input: {
+  originalPrompt: string;
+  output: string;
+}): OutputValidation {
+  const text = input.output.trim();
+  if (text === "") {
+    return fail("empty_output", "The rewrite agent returned empty output.");
+  }
+  if (text.length > MAX_OUTPUT_CHARS) {
+    return fail(
+      "generation_failed",
+      `The rewrite agent returned ${text.length} characters, over the ${MAX_OUTPUT_CHARS} character limit.`,
+    );
+  }
+  if (countFences(text) % 2 !== 0) {
+    return fail("generation_failed", "The rewrite output contains an unclosed code fence.");
+  }
+  if (isFullMarkdownEnvelope(text) && !isFullMarkdownEnvelope(input.originalPrompt)) {
+    return fail("generation_failed", "The rewrite output is wrapped in a markdown code fence.");
+  }
+
+  const lines = nonEmptyLines(text);
+  const first = lines[0];
+  if (
+    first !== undefined &&
+    META_PREFACE.test(first) &&
+    !input.originalPrompt.includes(first)
+  ) {
+    return fail("generation_failed", "The rewrite output starts with a preface, not the prompt.");
+  }
+  // A refusal is the whole answer: short, one or two lines, and not the user's text.
+  if (
+    first !== undefined &&
+    REFUSAL.test(first) &&
+    lines.length <= 2 &&
+    wordCount(text) <= 12 &&
+    !input.originalPrompt.includes(first)
+  ) {
+    return fail("generation_failed", "The rewrite agent refused to rewrite the prompt.");
+  }
+  // Commentary about the prompt is not the rewritten prompt, however long it is.
+  if (
+    first !== undefined &&
+    COMMENTARY.test(first) &&
+    !input.originalPrompt.includes(first)
+  ) {
+    return fail(
+      "generation_failed",
+      "The rewrite output comments on the prompt instead of rewriting it.",
+    );
+  }
+
+  const missing = findMissingProtectedLiterals(input.originalPrompt, text);
+  if (missing.length > 0) {
+    return fail(
+      "protected_literal_loss",
+      `The rewrite dropped ${missing.length} protected literal(s): ${missing
+        .slice(0, 5)
+        .map((literal) => `${literal.kind.replace("_", " ")} "${clip(literal.value)}"`)
+        .join(", ")}`,
+    );
+  }
+  return { ok: true, text };
+}

package/server/transports/api/anthropic.ts

@@ -0,0 +1,61 @@
+import { at, authHeaders, joinUrl, stringFieldAt, type ApiCall, type ApiHttpRequest, type ApiModelsCall, type ApiProtocol } from "./protocol.js";
+
+/**
+ * The Anthropic Messages protocol.
+ *
+ * Anthropic takes the instruction in a top-level `system` field rather than in
+ * the message list, requires `max_tokens`, and authenticates with `x-api-key`
+ * plus an explicit version header. It is also the shape z.ai, Alibaba/Qwen and
+ * most Anthropic-compatible gateways expose, so those are `baseUrl` entries.
+ *
+ * `max_tokens` is required here and cannot be omitted, so a rewrite budget is
+ * fixed at a value far above any rewritten prompt; the response stops on its own
+ * well before it.
+ */
+const MAX_TOKENS = 4_096;
+
+export const anthropicProtocol: ApiProtocol = {
+  id: "anthropic",
+  buildRequest(call: ApiCall): ApiHttpRequest {
+    return {
+      url: joinUrl(call.baseUrl, "/v1/messages"),
+      headers: {
+        "content-type": "application/json",
+        "anthropic-version": "2023-06-01",
+        ...authHeaders(call.apiKey, (key) => ({ "x-api-key": key })),
+      },
+      body: JSON.stringify({
+        model: call.model,
+        max_tokens: MAX_TOKENS,
+        temperature: 0,
+        system: call.systemPrompt,
+        messages: [{ role: "user", content: call.taskPrompt }],
+      }),
+    };
+  },
+  parseResponse(payload: unknown): string | null {
+    const content = at(payload, "content");
+    if (!Array.isArray(content)) return null;
+    // A response can interleave thinking blocks; only text blocks are the answer.
+    const parts: string[] = [];
+    for (const block of content) {
+      if (block === null || typeof block !== "object") continue;
+      const typed = block as { type?: unknown; text?: unknown };
+      if (typed.type === "text" && typeof typed.text === "string") parts.push(typed.text);
+    }
+    return parts.length === 0 ? null : parts.join("\n");
+  },
+  buildModelsRequest(call: ApiModelsCall): ApiHttpRequest {
+    return {
+      url: joinUrl(call.baseUrl, "/v1/models"),
+      headers: {
+        "anthropic-version": "2023-06-01",
+        ...authHeaders(call.apiKey, (key) => ({ "x-api-key": key })),
+      },
+      body: "",
+    };
+  },
+  parseModelsResponse(payload: unknown): string[] {
+    return stringFieldAt(payload, ["data"], "id");
+  },
+};