@kenkaiiii/gg-ai 4.2.70 → 4.2.72

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 
-type Provider = "anthropic" | "openai" | "glm" | "moonshot";
+type Provider = "anthropic" | "openai" | "glm" | "moonshot" | "palsu";
 type ThinkingLevel = "low" | "medium" | "high" | "max";
 type CacheRetention = "none" | "short" | "long";
 interface TextContent {
@@ -286,4 +286,73 @@ declare class ProviderError extends GGAIError {
     });
 }
 
-export { type AssistantMessage, type CacheRetention, type ContentPart, type DoneEvent, type ErrorEvent, EventStream, GGAIError, type ImageContent, type Message, type Provider, type ProviderEntry, ProviderError, type ProviderStreamFn, type RawContent, type ServerToolCall, type ServerToolCallEvent, type ServerToolDefinition, type ServerToolResult, type ServerToolResultEvent, type StopReason, type StreamEvent, type StreamOptions, type StreamResponse, StreamResult, type SystemMessage, type TextContent, type TextDeltaEvent, type ThinkingContent, type ThinkingDeltaEvent, type ThinkingLevel, type Tool, type ToolCall, type ToolCallDeltaEvent, type ToolCallDoneEvent, type ToolChoice, type ToolResult, type ToolResultMessage, type Usage, type UserMessage, providerRegistry, stream };
+interface PalsuProviderState {
+    callCount: number;
+}
+type PalsuResponseFactory = (messages: Message[], options: StreamOptions, state: PalsuProviderState) => AssistantMessage | Promise<AssistantMessage>;
+type PalsuResponse = AssistantMessage | PalsuResponseFactory;
+/** Create an assistant message with a single text block. */
+declare function palsuText(text: string): AssistantMessage;
+/** Create an assistant message with a thinking block and optional text reply. */
+declare function palsuThinking(thinking: string, text?: string): AssistantMessage;
+/** Create an assistant message with a single tool call. */
+declare function palsuToolCall(name: string, args: Record<string, unknown>, id?: string): AssistantMessage;
+/** Create an assistant message from content parts with optional stop reason. */
+declare function palsuAssistantMessage(content: ContentPart[], options?: {
+    stopReason?: StopReason;
+}): AssistantMessage & {
+    _stopReason?: StopReason;
+};
+interface PalsuModelConfig {
+    /** Default response for this model when its queue is empty. */
+    defaultResponse?: PalsuResponse;
+}
+interface PalsuModelHandle {
+    /** Replace this model's response queue. */
+    setResponses(responses: PalsuResponse[]): void;
+    /** Append responses to this model's queue. */
+    appendResponses(...responses: PalsuResponse[]): void;
+    /** Number of unconsumed responses in this model's queue. */
+    getPendingResponseCount(): number;
+}
+interface PalsuProviderHandle {
+    /** Replace the shared response queue entirely. */
+    setResponses(responses: PalsuResponse[]): void;
+    /** Append responses to the shared queue. */
+    appendResponses(...responses: PalsuResponse[]): void;
+    /** Number of unconsumed responses in the shared queue. */
+    getPendingResponseCount(): number;
+    /** Mutable state — tracks call count. */
+    state: PalsuProviderState;
+    /** Get a handle for a model-specific response queue. */
+    getModel(name: string): PalsuModelHandle;
+    /** Remove this provider from the registry. */
+    unregister(): void;
+}
+interface PalsuProviderConfig {
+    /** Provider name to register under. Default: "palsu". */
+    name?: string;
+    /** Response returned when all queues are empty. Default: empty text message. */
+    defaultResponse?: PalsuResponse;
+    /** Enable prompt cache simulation. Tracks common message prefixes across calls. */
+    promptCache?: boolean;
+    /** Model-specific configurations with per-model response queues. */
+    models?: Record<string, PalsuModelConfig>;
+}
+/**
+ * Register a palsu (mock) LLM provider for testing.
+ * Returns a handle to control responses and inspect state.
+ *
+ * ```ts
+ * const palsu = registerPalsuProvider();
+ * palsu.appendResponses(palsuText("Hello!"));
+ *
+ * const result = await stream({ provider: "palsu", model: "test", messages });
+ * console.log(result.message); // { role: "assistant", content: [{ type: "text", text: "Hello!" }] }
+ *
+ * palsu.unregister(); // cleanup
+ * ```
+ */
+declare function registerPalsuProvider(config?: PalsuProviderConfig): PalsuProviderHandle;
+
+export { type AssistantMessage, type CacheRetention, type ContentPart, type DoneEvent, type ErrorEvent, EventStream, GGAIError, type ImageContent, type Message, type PalsuModelConfig, type PalsuModelHandle, type PalsuProviderConfig, type PalsuProviderHandle, type PalsuProviderState, type PalsuResponse, type PalsuResponseFactory, type Provider, type ProviderEntry, ProviderError, type ProviderStreamFn, type RawContent, type ServerToolCall, type ServerToolCallEvent, type ServerToolDefinition, type ServerToolResult, type ServerToolResultEvent, type StopReason, type StreamEvent, type StreamOptions, type StreamResponse, StreamResult, type SystemMessage, type TextContent, type TextDeltaEvent, type ThinkingContent, type ThinkingDeltaEvent, type ThinkingLevel, type Tool, type ToolCall, type ToolCallDeltaEvent, type ToolCallDoneEvent, type ToolChoice, type ToolResult, type ToolResultMessage, type Usage, type UserMessage, palsuAssistantMessage, palsuText, palsuThinking, palsuToolCall, providerRegistry, registerPalsuProvider, stream };

package/dist/index.js

@@ -1166,12 +1166,174 @@ 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;
+}
 export {
   EventStream,
   GGAIError,
   ProviderError,
   StreamResult,
+  palsuAssistantMessage,
+  palsuText,
+  palsuThinking,
+  palsuToolCall,
   providerRegistry,
+  registerPalsuProvider,
   stream
 };
 //# sourceMappingURL=index.js.map