@prestyj/ai 4.2.56 → 4.2.75

package/README.md

@@ -42,7 +42,7 @@ Tool parameters are Zod schemas. Converted to JSON Schema at the provider bounda
 |---|---|---|
 | `anthropic` | Claude Opus 4.6, Sonnet 4.6, Haiku 4.5 | Extended thinking, prompt caching, server-side compaction |
 | `openai` | GPT-4.1, o3, o4-mini | Supports OAuth (codex endpoint) and API keys |
-| `glm` | GLM-5, GLM-4.7 | Z.AI platform, OpenAI-compatible |
+| `glm` | GLM-5.1, GLM-4.7 | Z.AI platform, OpenAI-compatible |
 | `moonshot` | Kimi K2.5 | Moonshot platform, OpenAI-compatible |
 
 ---

package/dist/index.cjs

@@ -34,7 +34,12 @@ __export(index_exports, {
   EventStream: () => EventStream,
   ProviderError: () => ProviderError,
   StreamResult: () => StreamResult,
+  palsuAssistantMessage: () => palsuAssistantMessage,
+  palsuText: () => palsuText,
+  palsuThinking: () => palsuThinking,
+  palsuToolCall: () => palsuToolCall,
   providerRegistry: () => providerRegistry,
+  registerPalsuProvider: () => registerPalsuProvider,
   stream: () => stream
 });
 module.exports = __toCommonJS(index_exports);
@@ -501,12 +506,19 @@ async function runStream(options, result) {
       ]
     } : {},
     ...options.toolChoice && options.tools?.length ? { tool_choice: toAnthropicToolChoice(options.toolChoice) } : {},
-    ...options.compaction ? { context_management: { edits: [{ type: "compact_20260112" }] } } : {},
+    ...(() => {
+      const contextEdits = [
+        ...options.compaction ? [{ type: "compact_20260112" }] : [],
+        ...options.clearToolUses ? [{ type: "clear_tool_uses_20250919" }] : []
+      ];
+      return contextEdits.length ? { context_management: { edits: contextEdits } } : {};
+    })(),
     stream: true
   };
   const betaHeaders = [
     ...isOAuth ? ["claude-code-20250219", "oauth-2025-04-20"] : [],
-    ...options.compaction ? ["compact-2026-01-12"] : []
+    ...options.compaction ? ["compact-2026-01-12"] : [],
+    ...options.clearToolUses ? ["context-management-2025-06-27"] : []
   ];
   const stream2 = client.messages.stream(params, {
     signal: options.signal ?? void 0,
@@ -693,12 +705,12 @@ async function runStream2(options, result) {
   for await (const chunk of stream2) {
     const choice = chunk.choices?.[0];
     if (chunk.usage) {
-      inputTokens = chunk.usage.prompt_tokens;
       outputTokens = chunk.usage.completion_tokens;
       const details = chunk.usage.prompt_tokens_details;
       if (details?.cached_tokens) {
         cacheRead = details.cached_tokens;
       }
+      inputTokens = chunk.usage.prompt_tokens - cacheRead;
     }
     if (!choice) continue;
     if (choice.finish_reason) {
@@ -1200,13 +1212,175 @@ async function runGLMWithFallback(options, result) {
     }
   }
 }
+
+// src/providers/palsu.ts
+function palsuText(text) {
+  return { role: "assistant", content: text ? [{ type: "text", text }] : [] };
+}
+function palsuThinking(thinking, text) {
+  const content = [{ type: "thinking", text: thinking }];
+  if (text) content.push({ type: "text", text });
+  return { role: "assistant", content };
+}
+function palsuToolCall(name, args, id) {
+  return {
+    role: "assistant",
+    content: [{ type: "tool_call", id: id ?? `palsu_${name}_${Date.now()}`, name, args }]
+  };
+}
+function palsuAssistantMessage(content, options) {
+  return { role: "assistant", content, _stopReason: options?.stopReason };
+}
+var DEFAULT_CHUNK_SIZE = 20;
+function chunkText(text, size) {
+  const chunks = [];
+  for (let i = 0; i < text.length; i += size) {
+    chunks.push(text.slice(i, i + size));
+  }
+  return chunks.length > 0 ? chunks : [""];
+}
+function simulateStream(message, stopReason, result, signal, cacheUsage) {
+  if (signal?.aborted) {
+    result.abort(new Error("aborted"));
+    return;
+  }
+  const content = typeof message.content === "string" ? message.content ? [{ type: "text", text: message.content }] : [] : message.content;
+  let outputChars = 0;
+  for (const part of content) {
+    if (signal?.aborted) {
+      result.abort(new Error("aborted"));
+      return;
+    }
+    if (part.type === "text") {
+      const chunks = chunkText(part.text, DEFAULT_CHUNK_SIZE);
+      for (const chunk of chunks) {
+        result.push({ type: "text_delta", text: chunk });
+        outputChars += chunk.length;
+      }
+    } else if (part.type === "thinking") {
+      result.push({ type: "thinking_delta", text: part.text });
+      outputChars += part.text.length;
+    } else if (part.type === "tool_call") {
+      const argsJson = JSON.stringify(part.args);
+      result.push({ type: "toolcall_delta", id: part.id, name: part.name, argsJson });
+      result.push({ type: "toolcall_done", id: part.id, name: part.name, args: part.args });
+      outputChars += argsJson.length;
+    }
+  }
+  const outputTokens = Math.max(1, Math.ceil(outputChars / 4));
+  const usage = {
+    inputTokens: 100,
+    outputTokens,
+    ...cacheUsage?.cacheRead ? { cacheRead: cacheUsage.cacheRead } : {},
+    ...cacheUsage?.cacheWrite ? { cacheWrite: cacheUsage.cacheWrite } : {}
+  };
+  result.push({ type: "done", stopReason });
+  result.complete({ message, stopReason, usage });
+}
+function computeCacheUsage(current, previous) {
+  if (!previous) {
+    return { cacheRead: 0, cacheWrite: Math.ceil(current.length / 4) };
+  }
+  const maxLen = Math.min(current.length, previous.length);
+  let commonLen = 0;
+  for (let i = 0; i < maxLen; i++) {
+    if (current[i] !== previous[i]) break;
+    commonLen++;
+  }
+  return {
+    cacheRead: Math.ceil(commonLen / 4),
+    cacheWrite: Math.ceil((current.length - commonLen) / 4)
+  };
+}
+function registerPalsuProvider(config) {
+  const name = config?.name ?? "palsu";
+  const responses = [];
+  const state = { callCount: 0 };
+  const defaultResponse = config?.defaultResponse ?? palsuText("");
+  const enableCache = config?.promptCache ?? false;
+  let lastMessagesSerialized = null;
+  const modelStates = /* @__PURE__ */ new Map();
+  if (config?.models) {
+    for (const [modelName, modelConfig] of Object.entries(config.models)) {
+      modelStates.set(modelName, {
+        responses: [],
+        defaultResponse: modelConfig.defaultResponse
+      });
+    }
+  }
+  const handle = {
+    setResponses(r) {
+      responses.length = 0;
+      responses.push(...r);
+    },
+    appendResponses(...r) {
+      responses.push(...r);
+    },
+    getPendingResponseCount() {
+      return responses.length;
+    },
+    state,
+    getModel(modelName) {
+      if (!modelStates.has(modelName)) {
+        modelStates.set(modelName, { responses: [] });
+      }
+      const ms = modelStates.get(modelName);
+      return {
+        setResponses(r) {
+          ms.responses.length = 0;
+          ms.responses.push(...r);
+        },
+        appendResponses(...r) {
+          ms.responses.push(...r);
+        },
+        getPendingResponseCount() {
+          return ms.responses.length;
+        }
+      };
+    },
+    unregister() {
+      providerRegistry.unregister(name);
+    }
+  };
+  providerRegistry.register(name, {
+    stream(options) {
+      state.callCount++;
+      const ms = modelStates.get(options.model);
+      const responseDef = (ms && ms.responses.length > 0 ? ms.responses.shift() : void 0) ?? (responses.length > 0 ? responses.shift() : void 0) ?? ms?.defaultResponse ?? defaultResponse;
+      const result = new StreamResult();
+      let cacheUsage;
+      if (enableCache) {
+        const serialized = JSON.stringify(options.messages);
+        cacheUsage = computeCacheUsage(serialized, lastMessagesSerialized);
+        lastMessagesSerialized = serialized;
+      }
+      const rawMessage = typeof responseDef === "function" ? responseDef(options.messages, options, state) : responseDef;
+      Promise.resolve(rawMessage).then(
+        (message) => {
+          const hasToolCalls = Array.isArray(message.content) && message.content.some((p) => p.type === "tool_call");
+          const explicitStop = message._stopReason;
+          const stopReason = explicitStop ?? (hasToolCalls ? "tool_use" : "end_turn");
+          simulateStream(message, stopReason, result, options.signal, cacheUsage);
+        },
+        (err) => result.abort(err instanceof Error ? err : new Error(String(err)))
+      );
+      return result;
+    }
+  });
+  return handle;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   EZCoderAIError,
   EventStream,
   ProviderError,
   StreamResult,
+  palsuAssistantMessage,
+  palsuText,
+  palsuThinking,
+  palsuToolCall,
   providerRegistry,
+  registerPalsuProvider,
   stream
 });
 //# sourceMappingURL=index.cjs.map