@computesdk/pi-morph 1.0.3 → 1.0.4

package/index.ts

@@ -6,8 +6,15 @@
 // built-in `openai-completions` implementation handles the request/stream/tool-call plumbing. Load it with
 // `pi -e ./index.ts` or install the package (`pi install npm:@computesdk/pi-morph`).
 //
+// It uses the name+config form of `pi.registerProvider` on purpose: building a Provider with
+// `createProvider` needs a real API implementation, and the only export of one lives at the
+// `@earendil-works/pi-ai/api/openai-completions.lazy` subpath. Pi maps bare `@earendil-works/*` imports
+// to its own bundled copies but does not map subpaths, so that import resolves to the package's own
+// node_modules copy, which then fails at runtime under pnpm (its transitive deps are invisible to Pi's
+// bundled resolver). The config form names the built-in API by string and never imports pi-ai at runtime.
+//
 // Only the general chat models are registered. Morph's single-purpose models — Fast Apply (`morph-v3-fast`,
-// `morph-v3-large`, `auto`), WarpGrep (`morph-warp-grep-v2.1`), Compact and the Router — take bespoke request
+// `morph-v2`, `morph-v0`), WarpGrep (`morph-warp-grep-v2.1`), Compact and the Router — take bespoke request
 // shapes and are not chat models, so they are left out. `service_tier: "standby"` halves the price on
 // supported models; Pi can send it via `samplingParams` if you want it on.
 //
@@ -15,8 +22,7 @@
 // there when they change.
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { createProvider, envApiKeyAuth, type Model, type ThinkingLevelMap } from "@earendil-works/pi-ai";
-import { openAICompletionsApi } from "@earendil-works/pi-ai/api/openai-completions.lazy";
+import type { Model, ThinkingLevelMap } from "@earendil-works/pi-ai";
 
 const ID = "morph";
 const BASE_URL = "https://api.morphllm.com/v1";
@@ -61,17 +67,14 @@ export const MODELS: ChatModel[] = [
 ];
 
 export default function morphProvider(pi: ExtensionAPI) {
-  // A complete provider rather than the name+config form, because that is what carries native
-  // auth: envApiKeyAuth gives `/login morph` a key prompt, stores the credential in auth.json,
-  // and falls back to MORPH_API_KEY in the environment when nothing is stored.
-  pi.registerProvider(
-    createProvider({
-      id: ID,
-      name: "Morph",
-      baseUrl: BASE_URL,
-      auth: { apiKey: envApiKeyAuth("Morph API key", ["MORPH_API_KEY"]) },
-      models: MODELS,
-      api: openAICompletionsApi(),
-    }),
-  );
+  // Auth: the key `/login morph` stores in auth.json, or MORPH_API_KEY in the environment
+  // via the `$` interpolation (used when nothing is stored).
+  pi.registerProvider(ID, {
+    name: "Morph",
+    baseUrl: BASE_URL,
+    apiKey: "$MORPH_API_KEY",
+    api: "openai-completions",
+    authHeader: true,
+    models: MODELS,
+  });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@computesdk/pi-morph",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "description": "Morph for Pi: open-weight coding models (Kimi K3, GLM 5.3, DeepSeek V4) on Morph's OpenAI-compatible API, plus Fast Apply, Compact, and WarpGrep as tools.",
   "keywords": [
     "pi-package",

package/tools/apply.ts

@@ -4,8 +4,12 @@ import { defineTool, withFileMutationQueue } from "@earendil-works/pi-coding-age
 import { Type } from "typebox";
 import { post, usageFrom, type MorphUsage } from "./api.ts";
 
-/** Fast Apply merges an edit snippet into an existing file. `auto` lets Morph pick the model. */
-export const APPLY_MODELS = ["auto", "morph-v3-fast", "morph-v3-large"] as const;
+/**
+ * Fast Apply merges an edit snippet into an existing file. These are the models the `/code/apply`
+ * endpoint serves; it rejects anything else (including the documented `auto` and `morph-v3-large`)
+ * with `invalid_request_error`.
+ */
+export const APPLY_MODELS = ["morph-v3-fast", "morph-v2", "morph-v0"] as const;
 
 export const ApplyParams = Type.Object({
   path: Type.String({ description: "File to edit, relative to the working directory" }),
@@ -18,7 +22,7 @@ export const ApplyParams = Type.Object({
   model: Type.Optional(
     Type.Union(
       APPLY_MODELS.map((model) => Type.Literal(model)),
-      { description: "Fast Apply model. Default: auto." },
+      { description: "Fast Apply model. Default: morph-v3-fast." },
     ),
   ),
 });
@@ -39,7 +43,7 @@ export const applyTool = defineTool({
   annotations: { destructiveHint: true, openWorldHint: true },
   async execute(_toolCallId, params, signal, onUpdate, ctx) {
     const file = path.resolve(ctx.cwd, params.path);
-    const model = params.model ?? "auto";
+    const model = params.model ?? "morph-v3-fast";
     return withFileMutationQueue(file, async () => {
       let original: string;
       try {

package/tools/search.ts

@@ -378,6 +378,32 @@ export async function spanText(root: string, spans: Span[]): Promise<string> {
   return parts.join("\n\n");
 }
 
+/* ------------------------------------------------------------ text tool calls */
+
+// The API no longer parses WarpGrep's output into structured `tool_calls`: the model emits
+// Hermes-style text — `<tool_call>\n<function=read>\n<parameter=path>\n…\n</parameter>\n</function>\n</tool_call>`
+// — in `content`. Parse those blocks into the structured shape the loop below works with.
+// Arguments become a JSON string so `parseArgs` treats every call the same way.
+
+const TOOL_CALL_RE = /<tool_call>\s*<function=([\w-]+)>([\s\S]*?)<\/function>\s*<\/tool_call>/g;
+const PARAM_RE = /<parameter=([\w-]+)>([\s\S]*?)<\/parameter>/g;
+
+export function parseTextToolCalls(content: string, idPrefix = "textcall"): ChatToolCall[] {
+  const calls: ChatToolCall[] = [];
+  for (const block of content.matchAll(TOOL_CALL_RE)) {
+    const args: Record<string, string> = {};
+    for (const param of (block[2] as string).matchAll(PARAM_RE)) {
+      args[param[1] as string] = (param[2] as string).trim();
+    }
+    calls.push({
+      id: `${idPrefix}-${calls.length}`,
+      type: "function",
+      function: { name: block[1], arguments: JSON.stringify(args) },
+    });
+  }
+  return calls;
+}
+
 /* ----------------------------------------------------------------------- loop */
 
 export interface SearchResult {
@@ -418,7 +444,10 @@ export async function warpgrep(root: string, query: string, options: SearchOptio
     total.total_tokens = (total.total_tokens ?? 0) + (res.usage?.total_tokens ?? 0);
 
     const message = res.choices?.[0]?.message;
-    const calls = message?.tool_calls ?? [];
+    let calls = message?.tool_calls ?? [];
+    if (!calls.length && typeof message?.content === "string" && message.content.includes("<tool_call>")) {
+      calls = parseTextToolCalls(message.content, `textcall-${turn}`);
+    }
     options.onTurn?.(turn, calls.map((call) => call.function?.name ?? "?"));
 
     const finish = calls.find((call) => (call.function?.name ?? "").toLowerCase() === "finish");