shortcutxl 0.3.76 → 0.3.78

package/dist/app/collab/super-fight.js

@@ -1,310 +0,0 @@
-/**
- * Super Fight — Multiplayer ASCII fighting game engine.
- *
- * Headless game logic: state, physics, hit detection, sprite rendering,
- * frame composition, and network message encoding. Zero TUI dependencies.
- */
-// ── Constants ──────────────────────────────────────────────────────────────
-export const VIEWPORT_W = 80;
-export const VIEWPORT_H = 40;
-export const GROUND_Y = 34; // ground starts here (rows 34-39 are ground)
-export const GRAVITY = 0.8; // pixels per tick²
-export const JUMP_VY = -8; // initial upward velocity
-export const MOVE_SPEED = 2; // pixels per tick
-export const PUNCH_RANGE = 2;
-export const KICK_RANGE = 3;
-export const DAMAGE = 10;
-export const MAX_HEALTH = 100;
-export const RESPAWN_TIME = 3000; // ms
-export const TICK_MS = 66; // ~15 FPS
-export const SPRITE_W = 5;
-export const SPRITE_H = 5;
-export const GAME_MSG_PREFIX = '\x01GAME:';
-/** 8 bright ANSI colors for up to 8 players (wraps if more) */
-export const PLAYER_COLORS = [
-    '\x1b[91m', // bright red
-    '\x1b[92m', // bright green
-    '\x1b[93m', // bright yellow
-    '\x1b[94m', // bright blue
-    '\x1b[95m', // bright magenta
-    '\x1b[96m', // bright cyan
-    '\x1b[97m', // bright white
-    '\x1b[33m' // orange-ish (dark yellow)
-];
-export const RESET = '\x1b[0m';
-export function encodeGameMsg(msg) {
-    return GAME_MSG_PREFIX + JSON.stringify(msg);
-}
-export function decodeGameMsg(text) {
-    if (!text.startsWith(GAME_MSG_PREFIX))
-        return null;
-    try {
-        return JSON.parse(text.slice(GAME_MSG_PREFIX.length));
-    }
-    catch {
-        return null;
-    }
-}
-// ── Player Factory ─────────────────────────────────────────────────────────
-export function createPlayer(displayName, colorIndex, x) {
-    return {
-        x: x ?? Math.floor(Math.random() * (VIEWPORT_W - SPRITE_W * 2)) + SPRITE_W,
-        y: GROUND_Y - SPRITE_H,
-        vy: 0,
-        action: 'idle',
-        facing: 'right',
-        health: MAX_HEALTH,
-        kills: 0,
-        respawnTimer: 0,
-        color: PLAYER_COLORS[colorIndex % PLAYER_COLORS.length],
-        displayName,
-        actionTimer: 0
-    };
-}
-// ── Sprites ────────────────────────────────────────────────────────────────
-/**
- * Returns a 5-line array of the ASCII fighter sprite for the given pose.
- * All sprites are exactly SPRITE_W (5) chars wide.
- * `facing` flips the sprite horizontally.
- */
-export function renderSprite(action, facing) {
-    let lines;
-    switch (action) {
-        case 'idle':
-            lines = ['  O  ', ' /|\\ ', '  |  ', ' / \\ ', '/   \\'];
-            break;
-        case 'walk-left':
-        case 'walk-right':
-            lines = ['  O  ', ' /|\\ ', '  |  ', ' / \\ ', '|   |'];
-            break;
-        case 'jump':
-            lines = [' \\O/ ', '  |  ', '  |  ', ' / \\ ', '/   \\'];
-            break;
-        case 'crouch':
-            // Crouch is only 3 lines tall, padded with empty lines at top
-            lines = ['     ', '     ', '  O  ', ' /|\\ ', ' /_\\ '];
-            break;
-        case 'punch':
-            lines = ['  O  ', ' /|--', '  |  ', ' / \\ ', '/   \\'];
-            break;
-        case 'kick':
-            lines = ['  O  ', ' /|\\ ', '  |  ', ' /  _', '/    '];
-            break;
-        case 'hit':
-            lines = ['  O  ', '  |  ', ' /|\\ ', '  |  ', ' / \\ '];
-            break;
-        case 'dead':
-            lines = ['     ', '     ', '     ', '     ', '_O/|_'];
-            break;
-        default:
-            lines = ['  O  ', ' /|\\ ', '  |  ', ' / \\ ', '/   \\'];
-    }
-    // Flip horizontally if facing left
-    if (facing === 'left') {
-        lines = lines.map((line) => line
-            .split('')
-            .reverse()
-            .map((ch) => {
-            if (ch === '/')
-                return '\\';
-            if (ch === '\\')
-                return '/';
-            if (ch === '<')
-                return '>';
-            if (ch === '>')
-                return '<';
-            return ch;
-        })
-            .join(''));
-    }
-    return lines;
-}
-// ── Frame Renderer ─────────────────────────────────────────────────────────
-/**
- * Renders a complete game frame as an array of VIEWPORT_H strings,
- * each exactly VIEWPORT_W chars. No ANSI colors — caller wraps with color.
- * Returns { lines, colors } where colors[row][col] is the ANSI color code.
- */
-export function renderFrame(state, viewportW = VIEWPORT_W, viewportH = VIEWPORT_H) {
-    // Initialize blank frame buffer
-    const buf = Array.from({ length: viewportH }, () => Array(viewportW).fill(' '));
-    // Color buffer — one ANSI string per cell
-    const colorBuf = Array.from({ length: viewportH }, () => Array(viewportW).fill(''));
-    // Draw ground (rows GROUND_Y to viewportH-1)
-    for (let row = GROUND_Y; row < viewportH; row++) {
-        for (let col = 0; col < viewportW; col++) {
-            buf[row][col] = row === GROUND_Y ? '=' : '▓';
-        }
-    }
-    // Draw walls
-    for (let row = 0; row < viewportH; row++) {
-        buf[row][0] = '│';
-        buf[row][viewportW - 1] = '│';
-    }
-    // Sort players by x so overlapping sprites have consistent z-order
-    const players = [...state.entries()].sort((a, b) => a[1].x - b[1].x);
-    // Draw player sprites
-    for (const [, player] of players) {
-        const sprite = renderSprite(player.action, player.facing);
-        const px = Math.round(player.x);
-        const py = Math.round(player.y);
-        for (let sy = 0; sy < sprite.length; sy++) {
-            const row = py + sy;
-            if (row < 1 || row >= GROUND_Y)
-                continue; // skip out-of-bounds and ground
-            for (let sx = 0; sx < sprite[sy].length; sx++) {
-                const col = px + sx;
-                if (col < 1 || col >= viewportW - 1)
-                    continue; // skip walls
-                const ch = sprite[sy][sx];
-                if (ch !== ' ') {
-                    buf[row][col] = ch;
-                    colorBuf[row][col] = player.color;
-                }
-            }
-        }
-    }
-    // Render status bar at top (row 0)
-    let statusStr = '';
-    for (const [, player] of players) {
-        const healthBar = renderHealthBar(player.health);
-        const segment = ` ${player.displayName.slice(0, 8)}:${healthBar} K:${player.kills} `;
-        statusStr += segment;
-    }
-    statusStr = statusStr.slice(0, viewportW);
-    for (let i = 0; i < statusStr.length && i < viewportW; i++) {
-        buf[0][i] = statusStr[i];
-    }
-    // Compose final lines with ANSI colors
-    const lines = [];
-    for (let row = 0; row < viewportH; row++) {
-        let line = '';
-        let currentColor = '';
-        for (let col = 0; col < viewportW; col++) {
-            const cellColor = colorBuf[row][col];
-            if (cellColor !== currentColor) {
-                if (currentColor !== '')
-                    line += RESET;
-                if (cellColor !== '')
-                    line += cellColor;
-                currentColor = cellColor;
-            }
-            line += buf[row][col];
-        }
-        if (currentColor !== '')
-            line += RESET;
-        lines.push(line);
-    }
-    return lines;
-}
-function renderHealthBar(health) {
-    const filled = Math.ceil((health / MAX_HEALTH) * 10);
-    return '[' + '█'.repeat(filled) + '░'.repeat(10 - filled) + ']';
-}
-// ── Physics ────────────────────────────────────────────────────────────────
-/**
- * Update a single player's physics for one tick.
- * `dt` is the number of ticks elapsed (usually 1).
- */
-export function tickPlayer(player, dt = 1) {
-    // Dead players: count down respawn
-    if (player.action === 'dead') {
-        player.respawnTimer -= TICK_MS * dt;
-        if (player.respawnTimer <= 0) {
-            player.respawnTimer = 0;
-            player.health = MAX_HEALTH;
-            player.action = 'idle';
-            player.x = Math.floor(Math.random() * (VIEWPORT_W - SPRITE_W * 2)) + SPRITE_W;
-            player.y = GROUND_Y - SPRITE_H;
-            player.vy = 0;
-        }
-        return;
-    }
-    // Decay action timer (for punch/kick/hit animations)
-    if (player.actionTimer > 0) {
-        player.actionTimer -= dt;
-        if (player.actionTimer <= 0) {
-            player.actionTimer = 0;
-            if (player.action === 'punch' || player.action === 'kick' || player.action === 'hit') {
-                player.action = 'idle';
-            }
-        }
-    }
-    // Gravity
-    const onGround = player.y >= GROUND_Y - SPRITE_H;
-    if (!onGround) {
-        player.vy += GRAVITY * dt;
-        player.y += player.vy * dt;
-        // Land on ground
-        if (player.y >= GROUND_Y - SPRITE_H) {
-            player.y = GROUND_Y - SPRITE_H;
-            player.vy = 0;
-            if (player.action === 'jump') {
-                player.action = 'idle';
-            }
-        }
-    }
-    // Movement (only when walking)
-    if (player.action === 'walk-left') {
-        player.x -= MOVE_SPEED * dt;
-        player.facing = 'left';
-    }
-    else if (player.action === 'walk-right') {
-        player.x += MOVE_SPEED * dt;
-        player.facing = 'right';
-    }
-    // Clamp to arena bounds (inside walls)
-    player.x = Math.max(1, Math.min(VIEWPORT_W - SPRITE_W - 1, player.x));
-}
-// ── Hit Detection ──────────────────────────────────────────────────────────
-/**
- * Check whether `attacker` is currently hitting `target`.
- * Returns true if the attacker is punching/kicking and the target is in range.
- */
-export function checkHit(attacker, target) {
-    if (attacker.action !== 'punch' && attacker.action !== 'kick')
-        return false;
-    if (target.action === 'dead')
-        return false;
-    if (attacker.actionTimer <= 0)
-        return false; // animation expired
-    const range = attacker.action === 'punch' ? PUNCH_RANGE : KICK_RANGE;
-    // Center-x of each sprite
-    const ax = attacker.x + SPRITE_W / 2;
-    const tx = target.x + SPRITE_W / 2;
-    const dx = tx - ax;
-    // Check facing direction
-    if (attacker.facing === 'right' && dx < 0)
-        return false;
-    if (attacker.facing === 'left' && dx > 0)
-        return false;
-    // Check distance (horizontal range + sprite width overlap)
-    if (Math.abs(dx) > SPRITE_W + range)
-        return false;
-    // Check vertical overlap (must be roughly same height)
-    const ay = attacker.y;
-    const ty = target.y;
-    if (Math.abs(ay - ty) > SPRITE_H)
-        return false;
-    return true;
-}
-/**
- * Apply damage to a target. Returns true if the hit killed them.
- */
-export function applyDamage(target, amount) {
-    if (target.action === 'dead')
-        return false;
-    target.health -= amount;
-    if (target.health <= 0) {
-        target.health = 0;
-        target.action = 'dead';
-        target.respawnTimer = RESPAWN_TIME;
-        target.vy = 0;
-        return true;
-    }
-    // Hit stagger animation
-    target.action = 'hit';
-    target.actionTimer = 3; // 3 ticks of hit stagger
-    return false;
-}
-//# sourceMappingURL=super-fight.js.map

package/dist/app/collab/sync-bridge.d.ts

@@ -1,35 +0,0 @@
-/**
- * SyncBridge — wraps a mog SDK object's internal compute bridge to
- * expose Yrs CRDT sync primitives as binary (Uint8Array) operations.
- *
- * This is the ONLY file that touches mog SDK internals for CRDT sync.
- * If the mog team later exposes a public network sync API, swap this file.
- *
- * Internal access paths (both lead to the same ComputeBridge):
- *   HeadlessEngine → .lifecycle.computeBridge
- *   Workbook (WorkbookImpl) → .ctx.computeBridge
- */
-export declare class SyncBridge {
-    private bridge;
-    /**
-     * @param engineOrWorkbook - A mog HeadlessEngine or Workbook instance.
-     *   At runtime, both expose a compute bridge via internal properties.
-     */
-    constructor(engineOrWorkbook: any);
-    /** Full Yrs document state as binary — used for initial sync to server. */
-    getFullState(): Promise<Uint8Array>;
-    /** Local Yrs state vector — used in state-vector exchange protocol. */
-    getStateVector(): Promise<Uint8Array>;
-    /** Compute diff that would bring a remote (with given state vector) up to date. */
-    computeDiff(remoteSv: Uint8Array): Promise<Uint8Array>;
-    /** Apply a remote Yrs update to the local engine. */
-    applyUpdate(update: Uint8Array): Promise<void>;
-    /**
-     * Convert raw Yrs state bytes into a WorkbookSnapshot JSON string.
-     * Uses the NAPI addon's `yrs_state_to_snapshot_json` function.
-     */
-    static snapshotFromState(state: Uint8Array): string;
-    /** Return the native compute addon (for createHeadlessEngine's computeAddon param). */
-    static getNativeAddon(): any;
-}
-//# sourceMappingURL=sync-bridge.d.ts.map

package/dist/app/collab/sync-bridge.js

@@ -1,109 +0,0 @@
-/**
- * SyncBridge — wraps a mog SDK object's internal compute bridge to
- * expose Yrs CRDT sync primitives as binary (Uint8Array) operations.
- *
- * This is the ONLY file that touches mog SDK internals for CRDT sync.
- * If the mog team later exposes a public network sync API, swap this file.
- *
- * Internal access paths (both lead to the same ComputeBridge):
- *   HeadlessEngine → .lifecycle.computeBridge
- *   Workbook (WorkbookImpl) → .ctx.computeBridge
- */
-// ── Native addon loader ────────────────────────────────────────────────
-import { createRequire } from 'node:module';
-const PLATFORM_PACKAGES = {
-    darwin: { arm64: '@mog-sdk/darwin-arm64', x64: '@mog-sdk/darwin-x64' },
-    linux: { x64: '@mog-sdk/linux-x64-gnu', arm64: '@mog-sdk/linux-arm64-gnu' },
-    win32: { x64: '@mog-sdk/win32-x64-msvc' }
-};
-let _cachedAddon;
-/**
- * Load the platform-native compute addon.
- * Same resolution as @mog-sdk/sdk's internal tryLoadNapiAddon.
- *
- * Uses createRequire anchored to @mog-sdk/sdk's package location so
- * pnpm's symlinked node_modules resolves the platform package correctly.
- */
-function loadNativeAddon() {
-    if (_cachedAddon)
-        return _cachedAddon;
-    // Resolve the SDK's main entry, then create require from its directory.
-    // This ensures pnpm's symlinked deps (@mog-sdk/darwin-arm64 etc.) are findable.
-    const req = createRequire(import.meta.url);
-    const sdkEntry = req.resolve('@mog-sdk/sdk');
-    const sdkReq = createRequire(sdkEntry);
-    const pkg = PLATFORM_PACKAGES[process.platform]?.[process.arch];
-    if (!pkg)
-        throw new Error(`Unsupported platform: ${process.platform}/${process.arch}`);
-    _cachedAddon = sdkReq(pkg);
-    return _cachedAddon;
-}
-/**
- * Try to extract the compute bridge from various mog SDK object types.
- * Returns null if the object doesn't expose a compute bridge.
- */
-function extractComputeBridge(obj) {
-    // Path 1: HeadlessEngine → .lifecycle.computeBridge
-    const fromEngine = obj?.lifecycle?.computeBridge;
-    if (fromEngine && typeof fromEngine.syncStateVector === 'function') {
-        return fromEngine;
-    }
-    // Path 2: Workbook (WorkbookImpl) → .ctx.computeBridge
-    const fromWorkbook = obj?.ctx?.computeBridge;
-    if (fromWorkbook && typeof fromWorkbook.syncStateVector === 'function') {
-        return fromWorkbook;
-    }
-    return null;
-}
-// ── SyncBridge ─────────────────────────────────────────────────────────
-export class SyncBridge {
-    bridge;
-    /**
-     * @param engineOrWorkbook - A mog HeadlessEngine or Workbook instance.
-     *   At runtime, both expose a compute bridge via internal properties.
-     */
-    constructor(engineOrWorkbook) {
-        const bridge = extractComputeBridge(engineOrWorkbook);
-        if (!bridge) {
-            throw new Error('SyncBridge: object does not expose a compute bridge with sync methods');
-        }
-        this.bridge = bridge;
-    }
-    /** Full Yrs document state as binary — used for initial sync to server. */
-    async getFullState() {
-        const nums = await this.bridge.core.syncFullState();
-        return new Uint8Array(nums);
-    }
-    /** Local Yrs state vector — used in state-vector exchange protocol. */
-    async getStateVector() {
-        const nums = await this.bridge.syncStateVector();
-        return new Uint8Array(nums);
-    }
-    /** Compute diff that would bring a remote (with given state vector) up to date. */
-    async computeDiff(remoteSv) {
-        const nums = await this.bridge.syncDiff(Array.from(remoteSv));
-        return new Uint8Array(nums);
-    }
-    /** Apply a remote Yrs update to the local engine. */
-    async applyUpdate(update) {
-        await this.bridge.syncApply(Array.from(update));
-    }
-    // ── Static helpers ───────────────────────────────────────────────────
-    /**
-     * Convert raw Yrs state bytes into a WorkbookSnapshot JSON string.
-     * Uses the NAPI addon's `yrs_state_to_snapshot_json` function.
-     */
-    static snapshotFromState(state) {
-        const addon = loadNativeAddon();
-        const fn = addon.yrs_state_to_snapshot_json;
-        if (typeof fn !== 'function') {
-            throw new Error('SyncBridge: yrs_state_to_snapshot_json not found on NAPI addon');
-        }
-        return fn(Buffer.from(state));
-    }
-    /** Return the native compute addon (for createHeadlessEngine's computeAddon param). */
-    static getNativeAddon() {
-        return loadNativeAddon();
-    }
-}
-//# sourceMappingURL=sync-bridge.js.map

package/dist/app/collab/types.d.ts

@@ -1,75 +0,0 @@
-/**
- * Shared types for the real-time collaboration system.
- */
-export interface PeerInfo {
-    peerId: string;
-    displayName: string;
-    sheets?: SheetInfo[];
-}
-export interface SheetInfo {
-    id: string;
-    name: string;
-    usedRange: string | null;
-    cellCount: number;
-}
-export interface CollabState {
-    roomId: string | null;
-    peerId: string | null;
-    peers: Map<string, PeerInfo>;
-    connected: boolean;
-}
-export type ClientMessage = {
-    type: 'create';
-} | {
-    type: 'join';
-    roomId: string;
-    displayName: string;
-} | {
-    type: 'chat';
-    text: string;
-} | {
-    type: 'awareness';
-    sheets: SheetInfo[];
-} | {
-    type: 'leave';
-};
-export type ServerMessage = {
-    type: 'room_created';
-    roomId: string;
-} | {
-    type: 'joined';
-    roomId: string;
-    peerId: string;
-    peers: PeerInfo[];
-    docIds?: string[];
-} | {
-    type: 'peer_joined';
-    peerId: string;
-    displayName: string;
-} | {
-    type: 'peer_left';
-    peerId: string;
-} | {
-    type: 'chat';
-    peerId: string;
-    displayName: string;
-    text: string;
-} | {
-    type: 'awareness';
-    peerId: string;
-    displayName: string;
-    sheets: SheetInfo[];
-} | {
-    type: 'error';
-    message: string;
-};
-export interface CollabCallbacks {
-    onPeerJoined?: (peer: PeerInfo) => void;
-    onPeerLeft?: (peerId: string, displayName?: string) => void;
-    onChat?: (peerId: string, displayName: string, text: string) => void;
-    onAwareness?: (peerId: string, displayName: string, sheets: SheetInfo[]) => void;
-    onSyncData?: (docId: string, data: Uint8Array) => void;
-    onDisconnect?: () => void;
-    onError?: (message: string) => void;
-}
-//# sourceMappingURL=types.d.ts.map

package/dist/app/collab/types.js

@@ -1,5 +0,0 @@
-/**
- * Shared types for the real-time collaboration system.
- */
-export {};
-//# sourceMappingURL=types.js.map

package/dist/embedded-agent/ai-content.d.ts

@@ -1,52 +0,0 @@
-import type { DocumentContent, ImageContent, TextContent, ToolCall } from '../ai/types.js';
-import type { ShortcutXLModelInvokePayload } from '../contracts/model-call.js';
-/**
- * Shortcut document-content helpers.
- *
- * There are two distinct wire contracts in play:
- * - Private gateway: owned AI content is serialized directly to provider APIs
- *   (Anthropic Messages or OpenAI Responses).
- * - Normal Shortcut proxy invoke/helper calls: owned AI content is converted back to
- *   the multimodal block shapes accepted by the Shortcut invoke proxy and by
- *   helper LLM stream calls (sandbox_llm/screenshot).
- *
- * The normal Shortcut proxy is not one universal provider format. Claude/Haiku
- * gets Anthropic-native base64 blocks; Gemini/non-Anthropic gets the existing
- * LangChain multimodal shape (`image_url` for images, `media` for PDFs).
- */
-export type ShortcutXLUserContent = TextContent | ImageContent | DocumentContent;
-export declare function aiContentToShortcutProxyContent(content: string | readonly (ShortcutXLUserContent | ToolCall)[], model: string): ShortcutXLModelInvokePayload['messages'][number]['content'];
-export declare function aiUserContentToAnthropicContent(content: string | readonly ShortcutXLUserContent[], modelInput: readonly string[]): string | ({
-    readonly text: string;
-    readonly type: "text";
-} | {
-    readonly source: {
-        readonly data: string;
-        readonly media_type: string;
-        readonly type: "base64";
-    };
-    readonly type: "document" | "image";
-})[];
-export declare function aiUserContentToOpenAIResponsesContent(content: string | readonly ShortcutXLUserContent[]): ({
-    text: string;
-    type: string;
-    detail?: undefined;
-    image_url?: undefined;
-    file_data?: undefined;
-    filename?: undefined;
-} | {
-    detail: string;
-    image_url: string;
-    type: string;
-    text?: undefined;
-    file_data?: undefined;
-    filename?: undefined;
-} | {
-    file_data: string;
-    filename: string;
-    type: string;
-    text?: undefined;
-    detail?: undefined;
-    image_url?: undefined;
-})[];
-//# sourceMappingURL=ai-content.d.ts.map

package/dist/embedded-agent/ai-content.js

@@ -1,101 +0,0 @@
-function isAnthropicLikeModel(model) {
-    const normalized = model.toLowerCase();
-    return normalized.includes('claude') || normalized.includes('haiku');
-}
-function imageToShortcutProxyMultimodalBlock(block, model) {
-    if (isAnthropicLikeModel(model)) {
-        return {
-            source: {
-                data: block.data,
-                media_type: block.mimeType,
-                type: 'base64'
-            },
-            type: 'image'
-        };
-    }
-    // Normal Shortcut proxy non-Anthropic path: this is the existing LangChain
-    // multimodal image block consumed by Shortcut invoke and helper LLM stream
-    // calls.
-    return {
-        image_url: { url: `data:${block.mimeType};base64,${block.data}` },
-        type: 'image_url'
-    };
-}
-function documentToShortcutProxyMultimodalBlock(block, model) {
-    if (isAnthropicLikeModel(model)) {
-        return {
-            source: {
-                data: block.data,
-                media_type: block.mimeType,
-                type: 'base64'
-            },
-            type: 'document'
-        };
-    }
-    // Normal Shortcut proxy non-Anthropic path: LangChain multimodal `media`
-    // block for Gemini PDF input. This is not OpenAI Responses `input_file`.
-    return {
-        data: block.data,
-        mime_type: block.mimeType,
-        type: 'media'
-    };
-}
-export function aiContentToShortcutProxyContent(content, model) {
-    if (typeof content === 'string')
-        return content;
-    return content
-        .filter((block) => block.type === 'text' || block.type === 'image' || block.type === 'document')
-        .map((block) => block.type === 'text'
-        ? { text: block.text, type: 'text' }
-        : block.type === 'image'
-            ? imageToShortcutProxyMultimodalBlock(block, model)
-            : documentToShortcutProxyMultimodalBlock(block, model));
-}
-export function aiUserContentToAnthropicContent(content, modelInput) {
-    if (typeof content === 'string')
-        return content;
-    const blocks = content.map((block) => {
-        if (block.type === 'text') {
-            return { text: block.text, type: 'text' };
-        }
-        return {
-            source: {
-                data: block.data,
-                media_type: block.mimeType,
-                type: 'base64'
-            },
-            type: block.type
-        };
-    });
-    const filteredBlocks = modelInput.includes('image')
-        ? blocks
-        : blocks.filter((block) => block.type !== 'image');
-    return filteredBlocks.filter((block) => {
-        if (block.type === 'text')
-            return block.text.trim().length > 0;
-        return true;
-    });
-}
-export function aiUserContentToOpenAIResponsesContent(content) {
-    if (typeof content === 'string')
-        return [{ text: content, type: 'input_text' }];
-    return content.map((block) => {
-        if (block.type === 'text') {
-            return { text: block.text, type: 'input_text' };
-        }
-        if (block.type === 'image') {
-            return {
-                detail: 'auto',
-                image_url: `data:${block.mimeType};base64,${block.data}`,
-                type: 'input_image'
-            };
-        }
-        // OpenAI Responses accepts PDFs as input_file data URLs.
-        return {
-            file_data: `data:${block.mimeType};base64,${block.data}`,
-            filename: block.filename ?? 'document.pdf',
-            type: 'input_file'
-        };
-    });
-}
-//# sourceMappingURL=ai-content.js.map