@psnext/slingcli 2.4.20260507-3 → 2.4.20260509-2

package/node_modules/@mariozechner/pi-ai/dist/utils/overflow.js

@@ -1,146 +0,0 @@
-/**
- * Regex patterns to detect context overflow errors from different providers.
- *
- * These patterns match error messages returned when the input exceeds
- * the model's context window.
- *
- * Provider-specific patterns (with example error messages):
- *
- * - Anthropic: "prompt is too long: 213462 tokens > 200000 maximum"
- * - Anthropic: "413 {\"error\":{\"type\":\"request_too_large\",\"message\":\"Request exceeds the maximum size\"}}"
- * - OpenAI: "Your input exceeds the context window of this model"
- * - Google: "The input token count (1196265) exceeds the maximum number of tokens allowed (1048575)"
- * - xAI: "This model's maximum prompt length is 131072 but the request contains 537812 tokens"
- * - Groq: "Please reduce the length of the messages or completion"
- * - OpenRouter: "This endpoint's maximum context length is X tokens. However, you requested about Y tokens"
- * - llama.cpp: "the request exceeds the available context size, try increasing it"
- * - LM Studio: "tokens to keep from the initial prompt is greater than the context length"
- * - GitHub Copilot: "prompt token count of X exceeds the limit of Y"
- * - MiniMax: "invalid params, context window exceeds limit"
- * - Kimi For Coding: "Your request exceeded model token limit: X (requested: Y)"
- * - Cerebras: "400/413 status code (no body)"
- * - Mistral: "Prompt contains X tokens ... too large for model with Y maximum context length"
- * - z.ai: Does NOT error, accepts overflow silently - handled via usage.input > contextWindow
- * - Xiaomi MiMo: Truncates input to fill contextWindow exactly, then returns finish_reason "length"
- *   with output=0 (no room left to generate). Detected via stopReason "length" + zero output +
- *   input filling the context window.
- * - Ollama: Some deployments truncate silently, others return errors like "prompt too long; exceeded max context length by X tokens"
- */
-const OVERFLOW_PATTERNS = [
-    /prompt is too long/i, // Anthropic token overflow
-    /request_too_large/i, // Anthropic request byte-size overflow (HTTP 413)
-    /input is too long for requested model/i, // Amazon Bedrock
-    /exceeds the context window/i, // OpenAI (Completions & Responses API)
-    /input token count.*exceeds the maximum/i, // Google (Gemini)
-    /maximum prompt length is \d+/i, // xAI (Grok)
-    /reduce the length of the messages/i, // Groq
-    /maximum context length is \d+ tokens/i, // OpenRouter (all backends)
-    /exceeds the limit of \d+/i, // GitHub Copilot
-    /exceeds the available context size/i, // llama.cpp server
-    /greater than the context length/i, // LM Studio
-    /context window exceeds limit/i, // MiniMax
-    /exceeded model token limit/i, // Kimi For Coding
-    /too large for model with \d+ maximum context length/i, // Mistral
-    /model_context_window_exceeded/i, // z.ai non-standard finish_reason surfaced as error text
-    /prompt too long; exceeded (?:max )?context length/i, // Ollama explicit overflow error
-    /context[_ ]length[_ ]exceeded/i, // Generic fallback
-    /too many tokens/i, // Generic fallback
-    /token limit exceeded/i, // Generic fallback
-    /^4(?:00|13)\s*(?:status code)?\s*\(no body\)/i, // Cerebras: 400/413 with no body
-];
-/**
- * Patterns that indicate non-overflow errors (e.g. rate limiting, server errors).
- * Error messages matching any of these are excluded from overflow detection
- * even if they also match an OVERFLOW_PATTERN.
- *
- * Example: Bedrock formats throttling errors as "ThrottlingException: Too many tokens,
- * please wait before trying again." which would match the /too many tokens/i overflow
- * pattern without this exclusion.
- */
-const NON_OVERFLOW_PATTERNS = [
-    /^(Throttling error|Service unavailable):/i, // AWS Bedrock non-overflow errors (human-readable prefixes from formatBedrockError)
-    /rate limit/i, // Generic rate limiting
-    /too many requests/i, // Generic HTTP 429 style
-];
-/**
- * Check if an assistant message represents a context overflow error.
- *
- * This handles two cases:
- * 1. Error-based overflow: Most providers return stopReason "error" with a
- *    specific error message pattern.
- * 2. Silent overflow: Some providers accept overflow requests and return
- *    successfully. For these, we check if usage.input exceeds the context window.
- *
- * ## Reliability by Provider
- *
- * **Reliable detection (returns error with detectable message):**
- * - Anthropic: "prompt is too long: X tokens > Y maximum" or "request_too_large"
- * - OpenAI (Completions & Responses): "exceeds the context window"
- * - Google Gemini: "input token count exceeds the maximum"
- * - xAI (Grok): "maximum prompt length is X but request contains Y"
- * - Groq: "reduce the length of the messages"
- * - Cerebras: 400/413 status code (no body)
- * - Mistral: "Prompt contains X tokens ... too large for model with Y maximum context length"
- * - OpenRouter (all backends): "maximum context length is X tokens"
- * - llama.cpp: "exceeds the available context size"
- * - LM Studio: "greater than the context length"
- * - Kimi For Coding: "exceeded model token limit: X (requested: Y)"
- *
- * **Unreliable detection:**
- * - z.ai: Sometimes accepts overflow silently (detectable via usage.input > contextWindow),
- *   sometimes returns rate limit errors. Pass contextWindow param to detect silent overflow.
- * - Xiaomi MiMo: Truncates input to fit contextWindow then returns stopReason "length" with
- *   output=0. Pass contextWindow param to detect via the "filled context + zero output" signal.
- * - Ollama: May truncate input silently for some setups, but may also return explicit
- *   overflow errors that match the patterns above. Silent truncation still cannot be
- *   detected here because we do not know the expected token count.
- *
- * ## Custom Providers
- *
- * If you've added custom models via settings.json, this function may not detect
- * overflow errors from those providers. To add support:
- *
- * 1. Send a request that exceeds the model's context window
- * 2. Check the errorMessage in the response
- * 3. Create a regex pattern that matches the error
- * 4. The pattern should be added to OVERFLOW_PATTERNS in this file, or
- *    check the errorMessage yourself before calling this function
- *
- * @param message - The assistant message to check
- * @param contextWindow - Optional context window size for detecting silent overflow (z.ai)
- * @returns true if the message indicates a context overflow
- */
-export function isContextOverflow(message, contextWindow) {
-    // Case 1: Check error message patterns
-    if (message.stopReason === "error" && message.errorMessage) {
-        // Skip messages matching known non-overflow patterns (e.g. throttling / rate-limit)
-        const isNonOverflow = NON_OVERFLOW_PATTERNS.some((p) => p.test(message.errorMessage));
-        if (!isNonOverflow && OVERFLOW_PATTERNS.some((p) => p.test(message.errorMessage))) {
-            return true;
-        }
-    }
-    // Case 2: Silent overflow (z.ai style) - successful but usage exceeds context
-    if (contextWindow && message.stopReason === "stop") {
-        const inputTokens = message.usage.input + message.usage.cacheRead;
-        if (inputTokens > contextWindow) {
-            return true;
-        }
-    }
-    // Case 3: Length-stop overflow (Xiaomi MiMo style) - server truncates oversized input
-    // to fit the context window, leaving no room for output. Returns stopReason "length"
-    // with output=0 and input+cacheRead filling the context window.
-    if (contextWindow && message.stopReason === "length" && message.usage.output === 0) {
-        const inputTokens = message.usage.input + message.usage.cacheRead;
-        if (inputTokens >= contextWindow * 0.99) {
-            return true;
-        }
-    }
-    return false;
-}
-/**
- * Get the overflow patterns for testing purposes.
- */
-export function getOverflowPatterns() {
-    return [...OVERFLOW_PATTERNS];
-}
-//# sourceMappingURL=overflow.js.map

package/node_modules/@mariozechner/pi-ai/dist/utils/sanitize-unicode.js

@@ -1,26 +0,0 @@
-/**
- * Removes unpaired Unicode surrogate characters from a string.
- *
- * Unpaired surrogates (high surrogates 0xD800-0xDBFF without matching low surrogates 0xDC00-0xDFFF,
- * or vice versa) cause JSON serialization errors in many API providers.
- *
- * Valid emoji and other characters outside the Basic Multilingual Plane use properly paired
- * surrogates and will NOT be affected by this function.
- *
- * @param text - The text to sanitize
- * @returns The sanitized text with unpaired surrogates removed
- *
- * @example
- * // Valid emoji (properly paired surrogates) are preserved
- * sanitizeSurrogates("Hello 🙈 World") // => "Hello 🙈 World"
- *
- * // Unpaired high surrogate is removed
- * const unpaired = String.fromCharCode(0xD83D); // high surrogate without low
- * sanitizeSurrogates(`Text ${unpaired} here`) // => "Text  here"
- */
-export function sanitizeSurrogates(text) {
-    // Replace unpaired high surrogates (0xD800-0xDBFF not followed by low surrogate)
-    // Replace unpaired low surrogates (0xDC00-0xDFFF not preceded by high surrogate)
-    return text.replace(/[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g, "");
-}
-//# sourceMappingURL=sanitize-unicode.js.map

package/node_modules/@mariozechner/pi-ai/dist/utils/typebox-helpers.js

@@ -1,21 +0,0 @@
-import { Type } from "typebox";
-/**
- * Creates a string enum schema compatible with Google's API and other providers
- * that don't support anyOf/const patterns.
- *
- * @example
- * const OperationSchema = StringEnum(["add", "subtract", "multiply", "divide"], {
- *   description: "The operation to perform"
- * });
- *
- * type Operation = Static<typeof OperationSchema>; // "add" | "subtract" | "multiply" | "divide"
- */
-export function StringEnum(values, options) {
-    return Type.Unsafe({
-        type: "string",
-        enum: values,
-        ...(options?.description && { description: options.description }),
-        ...(options?.default && { default: options.default }),
-    });
-}
-//# sourceMappingURL=typebox-helpers.js.map

package/node_modules/@mariozechner/pi-ai/dist/utils/validation.js

@@ -1,281 +0,0 @@
-import { Compile } from "typebox/compile";
-import { Value } from "typebox/value";
-const validatorCache = new WeakMap();
-const TYPEBOX_KIND = Symbol.for("TypeBox.Kind");
-function isRecord(value) {
-    return typeof value === "object" && value !== null;
-}
-function isJsonSchemaObject(value) {
-    return isRecord(value);
-}
-function hasTypeBoxMetadata(schema) {
-    return isRecord(schema) && Object.getOwnPropertySymbols(schema).includes(TYPEBOX_KIND);
-}
-function getSchemaTypes(schema) {
-    if (typeof schema.type === "string") {
-        return [schema.type];
-    }
-    if (Array.isArray(schema.type)) {
-        return schema.type.filter((type) => typeof type === "string");
-    }
-    return [];
-}
-function matchesJsonType(value, type) {
-    switch (type) {
-        case "number":
-            return typeof value === "number";
-        case "integer":
-            return typeof value === "number" && Number.isInteger(value);
-        case "boolean":
-            return typeof value === "boolean";
-        case "string":
-            return typeof value === "string";
-        case "null":
-            return value === null;
-        case "array":
-            return Array.isArray(value);
-        case "object":
-            return isRecord(value) && !Array.isArray(value);
-        default:
-            return false;
-    }
-}
-function isValidatorSchema(value) {
-    return isRecord(value);
-}
-function getSubSchemaValidator(schema) {
-    if (!isValidatorSchema(schema)) {
-        return undefined;
-    }
-    try {
-        return getValidator(schema);
-    }
-    catch {
-        return undefined;
-    }
-}
-function coercePrimitiveByType(value, type) {
-    switch (type) {
-        case "number": {
-            if (value === null) {
-                return 0;
-            }
-            if (typeof value === "string" && value.trim() !== "") {
-                const parsed = Number(value);
-                if (Number.isFinite(parsed)) {
-                    return parsed;
-                }
-            }
-            if (typeof value === "boolean") {
-                return value ? 1 : 0;
-            }
-            return value;
-        }
-        case "integer": {
-            if (value === null) {
-                return 0;
-            }
-            if (typeof value === "string" && value.trim() !== "") {
-                const parsed = Number(value);
-                if (Number.isInteger(parsed)) {
-                    return parsed;
-                }
-            }
-            if (typeof value === "boolean") {
-                return value ? 1 : 0;
-            }
-            return value;
-        }
-        case "boolean": {
-            if (value === null) {
-                return false;
-            }
-            if (typeof value === "string") {
-                if (value === "true") {
-                    return true;
-                }
-                if (value === "false") {
-                    return false;
-                }
-            }
-            if (typeof value === "number") {
-                if (value === 1) {
-                    return true;
-                }
-                if (value === 0) {
-                    return false;
-                }
-            }
-            return value;
-        }
-        case "string": {
-            if (value === null) {
-                return "";
-            }
-            if (typeof value === "number" || typeof value === "boolean") {
-                return String(value);
-            }
-            return value;
-        }
-        case "null": {
-            if (value === "" || value === 0 || value === false) {
-                return null;
-            }
-            return value;
-        }
-        default:
-            return value;
-    }
-}
-function applySchemaObjectCoercion(value, schema) {
-    const properties = schema.properties;
-    const definedKeys = new Set(properties ? Object.keys(properties) : []);
-    if (properties) {
-        for (const [key, propertySchema] of Object.entries(properties)) {
-            if (!(key in value)) {
-                continue;
-            }
-            value[key] = coerceWithJsonSchema(value[key], propertySchema);
-        }
-    }
-    if (schema.additionalProperties && isJsonSchemaObject(schema.additionalProperties)) {
-        for (const [key, propertyValue] of Object.entries(value)) {
-            if (definedKeys.has(key)) {
-                continue;
-            }
-            value[key] = coerceWithJsonSchema(propertyValue, schema.additionalProperties);
-        }
-    }
-}
-function applySchemaArrayCoercion(value, schema) {
-    if (Array.isArray(schema.items)) {
-        for (let index = 0; index < value.length; index++) {
-            const itemSchema = schema.items[index];
-            if (!itemSchema) {
-                continue;
-            }
-            value[index] = coerceWithJsonSchema(value[index], itemSchema);
-        }
-        return;
-    }
-    if (isJsonSchemaObject(schema.items)) {
-        for (let index = 0; index < value.length; index++) {
-            value[index] = coerceWithJsonSchema(value[index], schema.items);
-        }
-    }
-}
-function coerceWithUnionSchema(value, schemas) {
-    for (const schema of schemas) {
-        const candidate = structuredClone(value);
-        const coerced = coerceWithJsonSchema(candidate, schema);
-        const validator = getSubSchemaValidator(schema);
-        if (validator?.Check(coerced)) {
-            return coerced;
-        }
-    }
-    return value;
-}
-function coerceWithJsonSchema(value, schema) {
-    let nextValue = value;
-    if (Array.isArray(schema.allOf)) {
-        for (const nested of schema.allOf) {
-            nextValue = coerceWithJsonSchema(nextValue, nested);
-        }
-    }
-    if (Array.isArray(schema.anyOf)) {
-        nextValue = coerceWithUnionSchema(nextValue, schema.anyOf);
-    }
-    if (Array.isArray(schema.oneOf)) {
-        nextValue = coerceWithUnionSchema(nextValue, schema.oneOf);
-    }
-    const schemaTypes = getSchemaTypes(schema);
-    const matchesUnionMember = schemaTypes.length > 1 && schemaTypes.some((schemaType) => matchesJsonType(nextValue, schemaType));
-    if (schemaTypes.length > 0 && !matchesUnionMember) {
-        for (const schemaType of schemaTypes) {
-            const candidate = coercePrimitiveByType(nextValue, schemaType);
-            if (candidate !== nextValue) {
-                nextValue = candidate;
-                break;
-            }
-        }
-    }
-    if (schemaTypes.includes("object") && isRecord(nextValue) && !Array.isArray(nextValue)) {
-        applySchemaObjectCoercion(nextValue, schema);
-    }
-    if (schemaTypes.includes("array") && Array.isArray(nextValue)) {
-        applySchemaArrayCoercion(nextValue, schema);
-    }
-    return nextValue;
-}
-function getValidator(schema) {
-    const key = schema;
-    const cached = validatorCache.get(key);
-    if (cached) {
-        return cached;
-    }
-    const validator = Compile(schema);
-    validatorCache.set(key, validator);
-    return validator;
-}
-function formatValidationPath(error) {
-    if (error.keyword === "required") {
-        const requiredProperties = error.params.requiredProperties;
-        const requiredProperty = requiredProperties?.[0];
-        if (requiredProperty) {
-            const basePath = error.instancePath.replace(/^\//, "").replace(/\//g, ".");
-            return basePath ? `${basePath}.${requiredProperty}` : requiredProperty;
-        }
-    }
-    const path = error.instancePath.replace(/^\//, "").replace(/\//g, ".");
-    return path || "root";
-}
-/**
- * Finds a tool by name and validates the tool call arguments against its TypeBox schema
- * @param tools Array of tool definitions
- * @param toolCall The tool call from the LLM
- * @returns The validated arguments
- * @throws Error if tool is not found or validation fails
- */
-export function validateToolCall(tools, toolCall) {
-    const tool = tools.find((t) => t.name === toolCall.name);
-    if (!tool) {
-        throw new Error(`Tool "${toolCall.name}" not found`);
-    }
-    return validateToolArguments(tool, toolCall);
-}
-/**
- * Validates tool call arguments against the tool's TypeBox schema
- * @param tool The tool definition with TypeBox schema
- * @param toolCall The tool call from the LLM
- * @returns The validated (and potentially coerced) arguments
- * @throws Error with formatted message if validation fails
- */
-export function validateToolArguments(tool, toolCall) {
-    const args = structuredClone(toolCall.arguments);
-    Value.Convert(tool.parameters, args);
-    const validator = getValidator(tool.parameters);
-    if (!hasTypeBoxMetadata(tool.parameters) && isJsonSchemaObject(tool.parameters)) {
-        const coerced = coerceWithJsonSchema(args, tool.parameters);
-        if (coerced !== args) {
-            if (isRecord(args) && isRecord(coerced)) {
-                for (const key of Object.keys(args)) {
-                    delete args[key];
-                }
-                Object.assign(args, coerced);
-            }
-            else {
-                return validator.Check(coerced) ? coerced : args;
-            }
-        }
-    }
-    if (validator.Check(args)) {
-        return args;
-    }
-    const errors = validator
-        .Errors(args)
-        .map((error) => `  - ${formatValidationPath(error)}: ${error.message}`)
-        .join("\n") || "Unknown validation error";
-    const errorMessage = `Validation failed for tool "${toolCall.name}":\n${errors}\n\nReceived arguments:\n${JSON.stringify(toolCall.arguments, null, 2)}`;
-    throw new Error(errorMessage);
-}
-//# sourceMappingURL=validation.js.map

package/node_modules/@mariozechner/pi-ai/package.json

@@ -1,108 +0,0 @@
-{
-	"name": "@mariozechner/pi-ai",
-	"version": "0.73.0",
-	"description": "Unified LLM API with automatic model discovery and provider configuration",
-	"type": "module",
-	"main": "./dist/index.js",
-	"types": "./dist/index.d.ts",
-	"exports": {
-		".": {
-			"types": "./dist/index.d.ts",
-			"import": "./dist/index.js"
-		},
-		"./anthropic": {
-			"types": "./dist/providers/anthropic.d.ts",
-			"import": "./dist/providers/anthropic.js"
-		},
-		"./azure-openai-responses": {
-			"types": "./dist/providers/azure-openai-responses.d.ts",
-			"import": "./dist/providers/azure-openai-responses.js"
-		},
-		"./google": {
-			"types": "./dist/providers/google.d.ts",
-			"import": "./dist/providers/google.js"
-		},
-		"./google-vertex": {
-			"types": "./dist/providers/google-vertex.d.ts",
-			"import": "./dist/providers/google-vertex.js"
-		},
-		"./mistral": {
-			"types": "./dist/providers/mistral.d.ts",
-			"import": "./dist/providers/mistral.js"
-		},
-		"./openai-codex-responses": {
-			"types": "./dist/providers/openai-codex-responses.d.ts",
-			"import": "./dist/providers/openai-codex-responses.js"
-		},
-		"./openai-completions": {
-			"types": "./dist/providers/openai-completions.d.ts",
-			"import": "./dist/providers/openai-completions.js"
-		},
-		"./openai-responses": {
-			"types": "./dist/providers/openai-responses.d.ts",
-			"import": "./dist/providers/openai-responses.js"
-		},
-		"./oauth": {
-			"types": "./dist/oauth.d.ts",
-			"import": "./dist/oauth.js"
-		},
-		"./bedrock-provider": {
-			"types": "./dist/bedrock-provider.d.ts",
-			"import": "./dist/bedrock-provider.js"
-		}
-	},
-	"bin": {
-		"pi-ai": "./dist/cli.js"
-	},
-	"files": [
-		"dist",
-		"README.md"
-	],
-	"scripts": {
-		"clean": "shx rm -rf dist",
-		"generate-models": "npx tsx scripts/generate-models.ts",
-		"build": "npm run generate-models && tsgo -p tsconfig.build.json",
-		"dev": "tsgo -p tsconfig.build.json --watch --preserveWatchOutput",
-		"dev:tsc": "tsgo -p tsconfig.build.json --watch --preserveWatchOutput",
-		"test": "vitest --run",
-		"prepublishOnly": "npm run clean && npm run build"
-	},
-	"dependencies": {
-		"@anthropic-ai/sdk": "^0.91.1",
-		"@aws-sdk/client-bedrock-runtime": "^3.1030.0",
-		"@google/genai": "^1.40.0",
-		"@mistralai/mistralai": "^2.2.0",
-		"typebox": "^1.1.24",
-		"chalk": "^5.6.2",
-		"openai": "6.26.0",
-		"partial-json": "^0.1.7",
-		"proxy-agent": "^6.5.0",
-		"undici": "^7.19.1",
-		"zod-to-json-schema": "^3.24.6"
-	},
-	"keywords": [
-		"ai",
-		"llm",
-		"openai",
-		"anthropic",
-		"gemini",
-		"bedrock",
-		"unified",
-		"api"
-	],
-	"author": "Mario Zechner",
-	"license": "MIT",
-	"repository": {
-		"type": "git",
-		"url": "git+https://github.com/badlogic/pi-mono.git",
-		"directory": "packages/ai"
-	},
-	"engines": {
-		"node": ">=20.0.0"
-	},
-	"devDependencies": {
-		"@types/node": "^24.3.0",
-		"canvas": "^3.2.0",
-		"vitest": "^3.2.4"
-	}
-}

package/node_modules/@mariozechner/pi-coding-agent/dist/bun/register-bedrock.js

@@ -1,4 +0,0 @@
-import { setBedrockProviderModule } from "@mariozechner/pi-ai";
-import { bedrockProviderModule } from "@mariozechner/pi-ai/bedrock-provider";
-setBedrockProviderModule(bedrockProviderModule);
-//# sourceMappingURL=register-bedrock.js.map

package/node_modules/@mariozechner/pi-coding-agent/dist/modes/interactive/components/keybinding-hints.js

@@ -1,22 +0,0 @@
-/**
- * Utilities for formatting keybinding hints in the UI.
- */
-import { getKeybindings } from "@mariozechner/pi-tui";
-import { theme } from "../theme/theme.js";
-function formatKeys(keys) {
-    if (keys.length === 0)
-        return "";
-    if (keys.length === 1)
-        return keys[0];
-    return keys.join("/");
-}
-export function keyText(keybinding) {
-    return formatKeys(getKeybindings().getKeys(keybinding));
-}
-export function keyHint(keybinding, description) {
-    return theme.fg("dim", keyText(keybinding)) + theme.fg("muted", ` ${description}`);
-}
-export function rawKeyHint(key, description) {
-    return theme.fg("dim", key) + theme.fg("muted", ` ${description}`);
-}
-//# sourceMappingURL=keybinding-hints.js.map