@lotagate/cli 0.1.20 → 0.1.22

package/dist/infrastructure/platform/host-process.d.ts

@@ -0,0 +1,17 @@
+import { type ChildProcess, type SpawnOptions } from 'node:child_process';
+import type { HostPlatformContext } from './host-platform.js';
+export interface PreparedPlatformCommand {
+    command: string;
+    args: readonly string[];
+    windowsVerbatimArguments: boolean;
+}
+export interface PlatformExecOptions {
+    cwd?: string;
+    env?: NonNullable<SpawnOptions['env']>;
+    maxBufferBytes?: number;
+}
+export declare function spawnPlatformProcess(command: string, args: readonly string[], platform: HostPlatformContext, options?: SpawnOptions): ChildProcess;
+export declare function execPlatformCommand(command: string, args: readonly string[], platform: HostPlatformContext, options?: PlatformExecOptions): Promise<void>;
+export declare function terminatePlatformProcess(child: ChildProcess, platform: HostPlatformContext): void;
+export declare function createSafeChildEnvironment(platform: HostPlatformContext): NonNullable<SpawnOptions['env']>;
+export declare function preparePlatformCommand(command: string, args: readonly string[], platform: HostPlatformContext): PreparedPlatformCommand;

package/dist/infrastructure/platform/host-process.js

@@ -0,0 +1,116 @@
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+const DEFAULT_EXEC_BUFFER_BYTES = 2 * 1024 * 1024;
+const WINDOWS_META_CHARS = /([()\][%!^"`<>&|;, *?])/gu;
+const WINDOWS_DIRECT_EXECUTABLE = /\.(?:com|exe)$/iu;
+const WINDOWS_CMD_SHIM = /node_modules[\\/]\.bin[\\/][^\\/]+\.cmd$/iu;
+export function spawnPlatformProcess(command, args, platform, options = {}) {
+    const prepared = preparePlatformCommand(command, args, platform);
+    return spawn(prepared.command, [...prepared.args], {
+        ...options,
+        shell: false,
+        windowsHide: true,
+        ...(prepared.windowsVerbatimArguments ? { windowsVerbatimArguments: true } : {}),
+    });
+}
+export function execPlatformCommand(command, args, platform, options = {}) {
+    const maxBufferBytes = options.maxBufferBytes ?? DEFAULT_EXEC_BUFFER_BYTES;
+    return new Promise((resolve, reject) => {
+        const child = spawnPlatformProcess(command, args, platform, {
+            ...(options.cwd === undefined ? {} : { cwd: options.cwd }),
+            ...(options.env === undefined ? {} : { env: options.env }),
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        const stdout = [];
+        const stderr = [];
+        let outputBytes = 0;
+        let settled = false;
+        const append = (target, chunk) => {
+            if (settled)
+                return;
+            outputBytes += chunk.byteLength;
+            if (outputBytes > maxBufferBytes) {
+                settled = true;
+                terminatePlatformProcess(child, platform);
+                reject(new Error('Process output exceeded the configured limit.'));
+                return;
+            }
+            target.push(chunk);
+        };
+        child.stdout?.on('data', (chunk) => append(stdout, chunk));
+        child.stderr?.on('data', (chunk) => append(stderr, chunk));
+        child.once('error', (error) => {
+            if (settled)
+                return;
+            settled = true;
+            reject(error);
+        });
+        child.once('close', (code) => {
+            if (settled)
+                return;
+            settled = true;
+            if (code === 0)
+                resolve();
+            else
+                reject(new Error(Buffer.concat(stderr).toString('utf8').trim() || `Process exited with code ${String(code)}.`));
+        });
+    });
+}
+export function terminatePlatformProcess(child, platform) {
+    const pid = child.pid;
+    if (pid === undefined)
+        return;
+    if (platform.isWindows) {
+        const killer = spawn('taskkill', ['/pid', String(pid), '/t', '/f'], { windowsHide: true, stdio: 'ignore' });
+        killer.once('error', () => child.kill());
+        return;
+    }
+    if (platform.supportsProcessGroups) {
+        try {
+            process.kill(-pid, 'SIGTERM');
+            return;
+        }
+        catch { /* Fall through when the process group is unavailable. */ }
+    }
+    child.kill();
+}
+export function createSafeChildEnvironment(platform) {
+    const keys = platform.isWindows
+        ? ['PATHEXT', 'SystemRoot', 'ComSpec', 'COMSPEC', 'TEMP', 'TMP', 'HOME', 'USERPROFILE', 'APPDATA', 'LOCALAPPDATA', 'LANG', 'LC_ALL']
+        : ['PATH', 'HOME', 'TMPDIR', 'TEMP', 'LANG', 'LC_ALL', 'XDG_RUNTIME_DIR', 'WAYLAND_DISPLAY', 'DISPLAY'];
+    const result = {};
+    if (platform.isWindows) {
+        const pathValue = platform.env['Path'] ?? platform.env['PATH'];
+        if (pathValue !== undefined)
+            result['Path'] = pathValue;
+    }
+    for (const key of keys) {
+        const value = platform.env[key];
+        if (value !== undefined)
+            result[key] = value;
+    }
+    return result;
+}
+export function preparePlatformCommand(command, args, platform) {
+    if (!platform.isWindows || WINDOWS_DIRECT_EXECUTABLE.test(command))
+        return { command, args, windowsVerbatimArguments: false };
+    const normalizedCommand = path.win32.normalize(command);
+    const doubleEscape = WINDOWS_CMD_SHIM.test(normalizedCommand);
+    const escapedCommand = escapeWindowsCommand(normalizedCommand);
+    const escapedArgs = args.map((arg) => escapeWindowsArgument(arg, doubleEscape));
+    return {
+        command: platform.env['ComSpec'] ?? platform.env['COMSPEC'] ?? 'cmd.exe',
+        args: ['/d', '/s', '/c', `"${[escapedCommand, ...escapedArgs].join(' ')}"`],
+        windowsVerbatimArguments: true,
+    };
+}
+function escapeWindowsCommand(value) {
+    return value.replace(WINDOWS_META_CHARS, '^$1');
+}
+function escapeWindowsArgument(value, doubleEscape) {
+    let escaped = value
+        .replace(/(?=(\\+?)?)\1"/gu, '$1$1\\"')
+        .replace(/(?=(\\+?)?)\1$/gu, '$1$1');
+    escaped = `"${escaped}"`.replace(WINDOWS_META_CHARS, '^$1');
+    return doubleEscape ? escaped.replace(WINDOWS_META_CHARS, '^$1') : escaped;
+}

package/dist/infrastructure/platform/platform-paths.d.ts

@@ -0,0 +1,25 @@
+import { type HostPlatformContext } from './host-platform.js';
+export interface PlatformPaths {
+    platform: HostPlatformContext;
+    home: string;
+    globalConfigDir: string;
+    globalConfigFile: string;
+    credentialsFile: string;
+    credentialKeyFile: string;
+    projectsDir: string;
+    cacheDir: string;
+    logsDir: string;
+    skillsDir: string;
+    pluginsDir: string;
+    mcpConfigFile: string;
+}
+export declare function resolvePlatformPaths(env?: Readonly<Record<string, string | undefined>>, platform?: HostPlatformContext): PlatformPaths;
+export declare function resolveProjectConfigPaths(cwd: string): {
+    directory: string;
+    settings: string;
+    localSettings: string;
+    skillsDir: string;
+    pluginsDir: string;
+    hooksDir: string;
+    mcpConfigFile: string;
+};

package/dist/infrastructure/platform/platform-paths.js

@@ -0,0 +1,33 @@
+import os from 'node:os';
+import path from 'node:path';
+import { detectHostPlatform } from './host-platform.js';
+export function resolvePlatformPaths(env = process.env, platform = detectHostPlatform({ env })) {
+    const home = env['LOTAGATE_HOME']?.trim() || os.homedir();
+    const root = path.join(home, '.lotagate');
+    return {
+        platform,
+        home,
+        globalConfigDir: root,
+        globalConfigFile: path.join(root, 'settings.json'),
+        credentialsFile: path.join(root, 'credentials.enc.json'),
+        credentialKeyFile: path.join(root, 'credentials.key'),
+        projectsDir: path.join(root, 'projects'),
+        cacheDir: path.join(root, 'cache'),
+        logsDir: path.join(root, 'logs'),
+        skillsDir: path.join(root, 'skills'),
+        pluginsDir: path.join(root, 'plugins'),
+        mcpConfigFile: path.join(root, 'mcp.json'),
+    };
+}
+export function resolveProjectConfigPaths(cwd) {
+    const directory = path.join(cwd, '.lotagate');
+    return {
+        directory,
+        settings: path.join(directory, 'settings.json'),
+        localSettings: path.join(directory, 'settings.local.json'),
+        skillsDir: path.join(directory, 'skills'),
+        pluginsDir: path.join(directory, 'plugins'),
+        hooksDir: path.join(directory, 'hooks'),
+        mcpConfigFile: path.join(directory, 'mcp.json'),
+    };
+}

package/dist/infrastructure/project/file-project-trust-store.d.ts

@@ -0,0 +1,12 @@
+import type { ProjectTrustStore, TrustedProject } from '../../ports/project-trust-store.js';
+import type { PlatformPaths } from '../platform/platform-paths.js';
+export declare class FileProjectTrustStore implements ProjectTrustStore {
+    private readonly filePath;
+    constructor(paths: PlatformPaths);
+    list(): Promise<readonly TrustedProject[]>;
+    get(fingerprint: string): Promise<TrustedProject | undefined>;
+    grant(project: TrustedProject): Promise<void>;
+    revoke(fingerprint: string): Promise<boolean>;
+    private read;
+    private write;
+}

package/dist/infrastructure/project/file-project-trust-store.js

@@ -0,0 +1,59 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { isFileNotFound } from '../filesystem/fs-errors.js';
+import { atomicWriteFile, withFileLock } from '../filesystem/atomic-file-store.js';
+import { readJsonFileBounded } from '../filesystem/bounded-json-reader.js';
+import { RESOURCE_LIMITS } from '../../domain/runtime/resource-limits.js';
+export class FileProjectTrustStore {
+    filePath;
+    constructor(paths) {
+        this.filePath = path.join(paths.globalConfigDir, 'trusted-projects.json');
+    }
+    async list() {
+        return (await this.read()).projects;
+    }
+    async get(fingerprint) {
+        return (await this.read()).projects.find((project) => project.fingerprint === fingerprint);
+    }
+    async grant(project) {
+        await withFileLock(this.filePath, async () => {
+            const file = await this.read();
+            const projects = file.projects.filter((candidate) => candidate.fingerprint !== project.fingerprint);
+            projects.push(project);
+            await this.write({ version: 1, projects });
+        });
+    }
+    async revoke(fingerprint) {
+        return withFileLock(this.filePath, async () => {
+            const file = await this.read();
+            const projects = file.projects.filter((project) => project.fingerprint !== fingerprint);
+            if (projects.length === file.projects.length)
+                return false;
+            await this.write({ version: 1, projects });
+            return true;
+        });
+    }
+    async read() {
+        try {
+            const value = await readJsonFileBounded(this.filePath, RESOURCE_LIMITS.configFileBytes);
+            if (!isTrustFile(value))
+                throw new Error('Invalid trust file.');
+            return value;
+        }
+        catch (error) {
+            if (isFileNotFound(error))
+                return { version: 1, projects: [] };
+            throw error;
+        }
+    }
+    async write(file) {
+        await fs.mkdir(path.dirname(this.filePath), { recursive: true });
+        await atomicWriteFile(this.filePath, `${JSON.stringify(file, null, 2)}\n`);
+    }
+}
+function isTrustFile(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const record = value;
+    return record['version'] === 1 && Array.isArray(record['projects']);
+}

package/dist/infrastructure/sdk/chat-completion-adapter.d.ts

@@ -0,0 +1,8 @@
+import { type LotaGate } from '@lotagate/sdk';
+import type { ChatModelPort, ChatModelRequest, ChatModelEvent } from '../../ports/chat-model.js';
+export declare class SdkChatCompletionAdapter implements ChatModelPort {
+    private readonly client;
+    constructor(client: LotaGate);
+    stream(request: ChatModelRequest): AsyncIterable<ChatModelEvent>;
+    private fallbackToBufferedCompletion;
+}

package/dist/infrastructure/sdk/chat-completion-adapter.js

@@ -0,0 +1,115 @@
+import { SdkErrorCode } from '@lotagate/sdk';
+import { CliError } from '../../domain/errors/cli-error.js';
+import { CLI_ERROR_CODES } from '../../domain/errors/error-codes.js';
+import { buildUserMessage } from '../clipboard/image-normalizer.js';
+export class SdkChatCompletionAdapter {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    async *stream(request) {
+        const messages = [
+            ...(request.system === undefined || request.system.trim().length === 0 ? [] : [{ role: 'system', content: request.system }]),
+            buildUserMessage(request.prompt, request.attachments),
+        ];
+        const options = request.signal === undefined ? undefined : { signal: request.signal };
+        let emittedDelta = false;
+        try {
+            yield { type: 'activity', state: 'connecting' };
+            const stream = await this.client.chat.completions.create({
+                model: request.model,
+                messages,
+                stream: true,
+            }, options);
+            yield { type: 'activity', state: 'thinking' };
+            for await (const chunk of stream) {
+                if (chunk.usage !== undefined)
+                    yield { type: 'usage', usage: mapUsage(chunk.usage) };
+                const content = chunk.choices[0]?.delta.content;
+                if (typeof content === 'string' && content.length > 0) {
+                    emittedDelta = true;
+                    yield { type: 'activity', state: 'writing' };
+                    yield { type: 'delta', content };
+                }
+            }
+            yield { type: 'activity', state: 'completed' };
+            yield { type: 'completed' };
+        }
+        catch (error) {
+            if (request.signal?.aborted === true) {
+                throw request.signal.reason ?? createAbortError();
+            }
+            if (!emittedDelta && isSseParseError(error)) {
+                yield* this.fallbackToBufferedCompletion(request, messages, options);
+                return;
+            }
+            throw new CliError(CLI_ERROR_CODES.MODEL_STREAM_FAILED, 'Chat completion stream failed.', {
+                category: 'model',
+                userMessage: 'Unable to read the model stream. The gateway may have returned an invalid SSE payload. Check the model, authentication and base URL.',
+                retryable: true,
+                cause: error,
+            });
+        }
+    }
+    async *fallbackToBufferedCompletion(request, messages, options) {
+        try {
+            const response = await this.client.chat.completions.create({
+                model: request.model,
+                messages: [...messages],
+                stream: false,
+            }, options);
+            if (response.usage !== undefined)
+                yield { type: 'usage', usage: mapUsage(response.usage) };
+            const content = textContent(response.choices[0]?.message.content);
+            if (content.length > 0) {
+                yield { type: 'activity', state: 'writing' };
+                yield { type: 'delta', content };
+            }
+            yield { type: 'activity', state: 'completed' };
+            yield { type: 'completed' };
+        }
+        catch (error) {
+            if (request.signal?.aborted === true) {
+                throw request.signal.reason ?? createAbortError();
+            }
+            throw new CliError(CLI_ERROR_CODES.MODEL_STREAM_FAILED, 'Chat completion fallback failed.', {
+                category: 'model',
+                userMessage: 'Unable to read the model response. Check the model, authentication and base URL.',
+                retryable: true,
+                cause: error,
+            });
+        }
+    }
+}
+function createAbortError() {
+    const error = new Error('The operation was aborted.');
+    error.name = 'AbortError';
+    return error;
+}
+function mapUsage(usage) {
+    return {
+        ...(typeof usage.prompt_tokens === 'number' ? { promptTokens: usage.prompt_tokens } : {}),
+        ...(typeof usage.completion_tokens === 'number' ? { completionTokens: usage.completion_tokens } : {}),
+        ...(typeof usage.total_tokens === 'number' ? { totalTokens: usage.total_tokens } : {}),
+    };
+}
+function isSseParseError(error) {
+    return typeof error === 'object'
+        && error !== null
+        && 'errorCode' in error
+        && error.errorCode === SdkErrorCode.ResponseParseError;
+}
+function textContent(content) {
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return '';
+    return content
+        .map((part) => {
+        if (typeof part !== 'object' || part === null || !('text' in part))
+            return '';
+        const text = part.text;
+        return typeof text === 'string' ? text : '';
+    })
+        .join('');
+}

package/dist/infrastructure/sdk/lotagate-client-factory.d.ts

@@ -0,0 +1,3 @@
+import { LotaGate } from '@lotagate/sdk';
+import type { AuthProfile } from '../../domain/auth/auth-profile.js';
+export declare function createLotaGateClient(profile: AuthProfile, apiKey: string): LotaGate;

package/dist/infrastructure/sdk/lotagate-client-factory.js

@@ -0,0 +1,8 @@
+import { LotaGate } from '@lotagate/sdk';
+export function createLotaGateClient(profile, apiKey) {
+    const options = {
+        apiKey,
+        baseURL: profile.baseUrl,
+    };
+    return new LotaGate(options);
+}

package/dist/infrastructure/sdk/model-catalog-adapter.d.ts

@@ -0,0 +1,19 @@
+import type { ModelListResponse, ModelSummary } from '@lotagate/sdk';
+export interface ModelCatalogClient {
+    models: {
+        list(): Promise<ModelListResponse>;
+        retrieve(model: string): Promise<ModelSummary>;
+    };
+}
+export declare class ModelCatalogAdapter {
+    private readonly client;
+    constructor(client: ModelCatalogClient);
+    /** Lists every selectable gateway model while excluding embeddings from interactive selection. */
+    listModels(): Promise<{
+        data: ModelSummary[];
+        object: "list" | string;
+    }>;
+    get(model: string): Promise<ModelSummary>;
+}
+/** Reads the optional gateway metadata without coupling the CLI to SDK internals. */
+export declare function getModelContextWindow(model: ModelSummary): number | undefined;

package/dist/infrastructure/sdk/model-catalog-adapter.js

@@ -0,0 +1,28 @@
+export class ModelCatalogAdapter {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    /** Lists every selectable gateway model while excluding embeddings from interactive selection. */
+    async listModels() {
+        const response = await this.client.models.list();
+        return {
+            ...response,
+            data: response.data.filter((model) => model['model_category'] !== 'embedding'),
+        };
+    }
+    async get(model) {
+        return this.client.models.retrieve(model);
+    }
+}
+/** Reads the optional gateway metadata without coupling the CLI to SDK internals. */
+export function getModelContextWindow(model) {
+    const value = model['context_window'];
+    if (typeof value === 'number' && Number.isInteger(value) && value > 0)
+        return value;
+    if (typeof value === 'string' && /^\d+$/u.test(value)) {
+        const parsed = Number(value);
+        return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : undefined;
+    }
+    return undefined;
+}

package/dist/infrastructure/sdk/sdk-media-gateway-client.d.ts

@@ -0,0 +1,20 @@
+import type { LotaGate } from '@lotagate/sdk';
+import type { MediaGatewayClient, AudioUploadInput, ImageEditInput, ImageGenerationInput, MediaRequestOptions, SpeechInput } from '../../ports/media-gateway-client.js';
+import type { GeneratedImage, MediaBinary, VideoOperation } from '../../domain/media/media-contract.js';
+/** SDK boundary adapter. Application code only sees CLI-owned media contracts. */
+export declare class SdkMediaGatewayClient implements MediaGatewayClient {
+    private readonly client;
+    constructor(client: LotaGate);
+    generateImage(input: ImageGenerationInput, options?: MediaRequestOptions): Promise<readonly GeneratedImage[]>;
+    editImage(input: ImageEditInput, options?: MediaRequestOptions): Promise<readonly GeneratedImage[]>;
+    createSpeech(input: SpeechInput, options?: MediaRequestOptions): Promise<MediaBinary>;
+    transcribe(input: AudioUploadInput, options?: MediaRequestOptions): Promise<string>;
+    translate(input: AudioUploadInput, options?: MediaRequestOptions): Promise<string>;
+    createVideo(input: {
+        model: string;
+        prompt: string;
+        parameters?: Record<string, unknown>;
+    }, options?: MediaRequestOptions): Promise<VideoOperation>;
+    getVideoOperation(id: string, options?: MediaRequestOptions): Promise<VideoOperation>;
+    downloadVideo(id: string, options?: MediaRequestOptions): Promise<MediaBinary>;
+}

package/dist/infrastructure/sdk/sdk-media-gateway-client.js

@@ -0,0 +1,97 @@
+/** SDK boundary adapter. Application code only sees CLI-owned media contracts. */
+export class SdkMediaGatewayClient {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    async generateImage(input, options) {
+        const response = await this.client.images.generations.create(toImageGenerationRequest(input), options);
+        return response.data.map((image) => ({
+            ...(typeof image.b64_json === 'string' ? { base64: image.b64_json } : {}),
+            ...(typeof image.url === 'string' ? { url: image.url } : {}),
+            ...(typeof image.revised_prompt === 'string' ? { revisedPrompt: image.revised_prompt } : {}),
+        }));
+    }
+    async editImage(input, options) {
+        const request = {
+            ...toImageGenerationRequest(input), image: input.images,
+            ...(input.mask === undefined ? {} : { mask: input.mask }),
+            ...(input.inputFidelity === undefined ? {} : { input_fidelity: input.inputFidelity }),
+        };
+        const response = await this.client.images.edits.create(request, options);
+        return response.data.map((image) => ({
+            ...(typeof image.b64_json === 'string' ? { base64: image.b64_json } : {}),
+            ...(typeof image.url === 'string' ? { url: image.url } : {}),
+            ...(typeof image.revised_prompt === 'string' ? { revisedPrompt: image.revised_prompt } : {}),
+        }));
+    }
+    async createSpeech(input, options) {
+        const response = await this.client.audio.speech.create({
+            model: input.model, input: input.input, voice: input.voice,
+            ...(input.instructions === undefined ? {} : { instructions: input.instructions }),
+            ...(input.responseFormat === undefined ? {} : { response_format: input.responseFormat }),
+            ...(input.speed === undefined ? {} : { speed: input.speed }),
+        }, options);
+        return binaryResponse(response);
+    }
+    async transcribe(input, options) {
+        const response = await this.client.audio.transcriptions.create(toTranscriptionRequest(input), options);
+        return response.text;
+    }
+    async translate(input, options) {
+        const response = await this.client.audio.translations.create(toTranslationRequest(input), options);
+        return response.text;
+    }
+    async createVideo(input, options) {
+        const request = { model: input.model, instances: [{ prompt: input.prompt }], ...(input.parameters === undefined ? {} : { parameters: input.parameters }) };
+        return toVideoOperation(await this.client.video.generations.create(request, options));
+    }
+    async getVideoOperation(id, options) {
+        return toVideoOperation(await this.client.video.operations.retrieve(id, options));
+    }
+    async downloadVideo(id, options) {
+        return binaryResponse(await this.client.video.operations.download(id, options));
+    }
+}
+function toImageGenerationRequest(input) {
+    return {
+        model: input.model, prompt: input.prompt,
+        ...(input.n === undefined ? {} : { n: input.n }), ...(input.size === undefined ? {} : { size: input.size }),
+        ...(input.quality === undefined ? {} : { quality: input.quality }), ...(input.background === undefined ? {} : { background: input.background }),
+        ...(input.outputFormat === undefined ? {} : { output_format: input.outputFormat }), ...(input.outputCompression === undefined ? {} : { output_compression: input.outputCompression }),
+        ...(input.moderation === undefined ? {} : { moderation: input.moderation }), ...(input.user === undefined ? {} : { user: input.user }),
+    };
+}
+function toTranscriptionRequest(input) {
+    const request = { model: input.model, file: input.file, filename: input.filename };
+    if (input.prompt !== undefined)
+        request.prompt = input.prompt;
+    if (input.temperature !== undefined)
+        request.temperature = input.temperature;
+    if (input.responseFormat !== undefined)
+        request.response_format = input.responseFormat;
+    if (input.language !== undefined)
+        request.language = input.language;
+    if (input.timestampGranularities !== undefined)
+        request.timestamp_granularities = [...input.timestampGranularities];
+    if (input.include !== undefined)
+        request.include = [...input.include];
+    return request;
+}
+function toTranslationRequest(input) {
+    const request = { model: input.model, file: input.file, filename: input.filename };
+    if (input.prompt !== undefined)
+        request.prompt = input.prompt;
+    if (input.temperature !== undefined)
+        request.temperature = input.temperature;
+    if (input.responseFormat !== undefined)
+        request.response_format = input.responseFormat;
+    return request;
+}
+function binaryResponse(response) {
+    const contentType = response.headers.get('content-type')?.split(';', 1)[0]?.trim();
+    return { bytes: new Uint8Array(response.data), ...(contentType === undefined || contentType.length === 0 ? {} : { contentType }) };
+}
+function toVideoOperation(operation) {
+    return { id: operation.name, done: operation.done === true, ...(typeof operation.error?.message === 'string' ? { errorMessage: operation.error.message } : {}) };
+}

package/dist/infrastructure/sessions/file-goal-store.d.ts

@@ -0,0 +1,21 @@
+import { type CreateGoalInput, type GoalEvaluation, type GoalState, type GoalUsageDelta } from '../../domain/orchestration/goal.js';
+import type { GoalStore } from '../../ports/goal-store.js';
+import type { SessionStore } from '../../ports/session-store.js';
+export declare class FileGoalStore implements GoalStore {
+    private readonly sessions;
+    constructor(sessions: SessionStore);
+    get(sessionId: string): Promise<GoalState | undefined>;
+    create(sessionId: string, input: CreateGoalInput): Promise<GoalState>;
+    replace(sessionId: string, input: CreateGoalInput): Promise<GoalState>;
+    pause(sessionId: string, reason?: string): Promise<GoalState>;
+    resume(sessionId: string): Promise<GoalState>;
+    recordTurn(sessionId: string): Promise<GoalState>;
+    recordUsage(sessionId: string, delta: GoalUsageDelta): Promise<GoalState>;
+    recordEvaluation(sessionId: string, evaluation: GoalEvaluation): Promise<GoalState>;
+    clear(sessionId: string, reason?: string): Promise<void>;
+    private requireActiveUnlocked;
+    private getOrThrowUnlocked;
+    private invalidState;
+    private appendState;
+    private append;
+}