@lotagate/cli 0.1.21 → 0.1.22

package/dist/infrastructure/agent-sdk/tool-calling-model-client.js

@@ -0,0 +1,447 @@
+import { SdkErrorCode } from '@lotagate/sdk';
+import { AssistantDeltaNormalizer } from '../../domain/runtime/assistant-delta-normalizer.js';
+/**
+ * Adapts the published SDK client to the Agent SDK model port and makes the
+ * intended tool-calling mode explicit for gateways that do not infer it from
+ * the presence of `tools` alone.
+ */
+export function createToolCallingModelClient(client, diagnostics = {}) {
+    const create = ((request, requestOptions) => {
+        if (request.stream === true) {
+            const stream = client.chat.completions.create(withAutomaticToolChoice({ ...request, stream: true }), requestOptions);
+            return observeStream(client, request, requestOptions, stream, request.model, diagnostics.onComplete);
+        }
+        return observeCompletion(client.chat.completions.create(withAutomaticToolChoice({ ...request, stream: false }), requestOptions), request.model, diagnostics.onComplete);
+    });
+    return { chat: { completions: { create } } };
+}
+async function observeCompletion(responsePromise, model, onComplete) {
+    const response = normalizeCompletionResponse(await responsePromise);
+    const message = response.choices[0]?.message;
+    onComplete?.({
+        model,
+        stream: false,
+        contentLength: textLength(message?.content),
+        toolCallCount: message?.tool_calls?.length ?? 0,
+        toolNames: (message?.tool_calls ?? []).map((call) => call.function.name),
+        ...(response.usage === undefined ? {} : { usage: mapUsage(response.usage) }),
+        ...(response.choices[0]?.finish_reason === undefined ? {} : { finishReason: response.choices[0].finish_reason }),
+    });
+    return response;
+}
+async function* observeStream(client, request, requestOptions, stream, model, onComplete) {
+    let contentLength = 0;
+    let finishReason;
+    const toolNames = new Set();
+    const toolCallIds = new Set();
+    const toolCallBuffer = new ToolCallStreamBuffer(request.tools);
+    let emittedMeaningfulFrame = false;
+    let usage;
+    let lastChunk;
+    let emittedBufferedToolCalls = false;
+    const deltaNormalizer = new AssistantDeltaNormalizer();
+    try {
+        for await (const rawChunk of stream) {
+            const normalizedChunk = normalizeChunkContent(rawChunk, deltaNormalizer);
+            const buffered = toolCallBuffer.consume(normalizedChunk);
+            const chunk = buffered.chunk;
+            const choice = chunk.choices[0];
+            if (chunk.usage !== undefined)
+                usage = mapUsage(chunk.usage);
+            const content = textLength(choice?.delta.content);
+            contentLength += content;
+            finishReason = choice?.finish_reason ?? finishReason;
+            if (content > 0 || buffered.hadToolCalls)
+                emittedMeaningfulFrame = true;
+            if (choice?.finish_reason === 'tool_calls' && !emittedBufferedToolCalls) {
+                const completed = toolCallBuffer.flush(chunk);
+                recordToolCalls(completed, toolCallIds, toolNames);
+                emittedBufferedToolCalls = true;
+                yield chunk;
+                yield completed;
+            }
+            else {
+                yield chunk;
+            }
+            lastChunk = chunk;
+        }
+        if (!emittedBufferedToolCalls && lastChunk !== undefined && toolCallBuffer.hasCalls()) {
+            const completed = toolCallBuffer.flush(lastChunk);
+            recordToolCalls(completed, toolCallIds, toolNames);
+            yield completed;
+        }
+    }
+    catch (error) {
+        if (!emittedMeaningfulFrame && isSseParseError(error) && requestOptions?.signal?.aborted !== true) {
+            const response = await client.chat.completions.create(withAutomaticToolChoice({ ...request, stream: false }), requestOptions);
+            if (response.usage !== undefined)
+                usage = mapUsage(response.usage);
+            const message = response.choices[0]?.message;
+            const bufferedContent = textLength(message?.content);
+            contentLength += bufferedContent;
+            for (const call of message?.tool_calls ?? []) {
+                if (call.id.length > 0)
+                    toolCallIds.add(call.id);
+                if (call.function.name.length > 0)
+                    toolNames.add(call.function.name);
+            }
+            finishReason = response.choices[0]?.finish_reason ?? finishReason;
+            yield bufferedResponseChunk(response);
+            return;
+        }
+        throw error;
+    }
+    finally {
+        onComplete?.({ model, stream: true, contentLength, toolCallCount: toolCallIds.size || toolNames.size, toolNames: [...toolNames], ...(finishReason === undefined ? {} : { finishReason }), ...(usage === undefined ? {} : { usage }) });
+    }
+}
+function withAutomaticToolChoice(request) {
+    return request.tools === undefined || request.tools.length === 0
+        ? request
+        : { ...request, tool_choice: 'auto' };
+}
+function bufferedResponseChunk(response) {
+    const normalized = normalizeCompletionResponse(response);
+    const choice = normalized.choices[0];
+    const message = choice?.message;
+    return {
+        id: normalized.id,
+        object: 'chat.completion.chunk',
+        created: normalized.created,
+        model: normalized.model,
+        choices: [{
+                index: choice?.index ?? 0,
+                delta: {
+                    role: 'assistant',
+                    content: textContent(message?.content),
+                    ...(message?.tool_calls === undefined ? {} : {
+                        tool_calls: message.tool_calls.map((call, index) => ({ ...call, index })),
+                    }),
+                },
+                ...(choice?.finish_reason === undefined ? {} : { finish_reason: choice.finish_reason }),
+            }],
+        ...(normalized.usage === undefined ? {} : { usage: normalized.usage }),
+    };
+}
+/**
+ * Some gateways encode streamed assistant text as content parts. The
+ * published Agent SDK consumes the portable string form for stream deltas, so
+ * normalize that provider representation at the CLI boundary without
+ * changing the external SDK contracts.
+ */
+function normalizeChunkContent(chunk, deltaNormalizer) {
+    return {
+        ...chunk,
+        choices: chunk.choices.map((choice) => {
+            const content = choice.delta.content;
+            const normalizedContent = Array.isArray(content)
+                ? deltaNormalizer.normalize(textContent(content))
+                : typeof content === 'string'
+                    ? deltaNormalizer.normalize(content)
+                    : content;
+            const rawDelta = choice.delta;
+            const providerToolCalls = [
+                ...(Array.isArray(content) ? extractProviderToolCalls(content) : []),
+                ...extractLegacyFunctionCall(rawDelta['function_call'], 0),
+            ];
+            const normalizedChoice = normalizedContent === content && providerToolCalls.length === 0 ? choice : {
+                ...choice,
+                delta: {
+                    ...choice.delta,
+                    ...(normalizedContent === content ? {} : { content: normalizedContent }),
+                    ...(providerToolCalls.length === 0 ? {} : { tool_calls: [...(choice.delta.tool_calls ?? []), ...providerToolCalls] }),
+                },
+            };
+            return normalizedChoice;
+        }),
+    };
+}
+/**
+ * Gateways can emit several overlapping tool-call frames, especially when a
+ * response contains multiple tools. Buffer them at the CLI boundary and emit
+ * one complete frame so the external Agent SDK never concatenates duplicated
+ * JSON fragments into an invalid argument payload.
+ */
+class ToolCallStreamBuffer {
+    knownNames;
+    calls = new Map();
+    order = [];
+    keysByPosition = new Map();
+    constructor(tools) {
+        this.knownNames = new Set((tools ?? []).flatMap((tool) => getToolNames(tool)));
+    }
+    consume(chunk) {
+        let hadToolCalls = false;
+        const choices = chunk.choices.map((choice) => {
+            const toolCalls = choice.delta.tool_calls;
+            if (toolCalls === undefined || toolCalls.length === 0)
+                return choice;
+            hadToolCalls = true;
+            toolCalls.forEach((call, position) => {
+                if (isRecord(call))
+                    this.append(call, position);
+            });
+            const delta = { ...choice.delta };
+            delete delta.tool_calls;
+            return { ...choice, delta };
+        });
+        return { chunk: { ...chunk, choices }, hadToolCalls };
+    }
+    hasCalls() { return this.order.length > 0; }
+    flush(chunk) {
+        const toolCalls = this.order.map((key, index) => {
+            const call = this.calls.get(key);
+            return {
+                id: call.id || `tool-call-${index}`,
+                type: call.type,
+                function: { name: call.name, arguments: call.arguments },
+                ...(call.providerMetadata === undefined ? {} : { provider_metadata: call.providerMetadata }),
+            };
+        });
+        const choices = chunk.choices.map((choice, index) => index === 0
+            ? { ...choice, delta: { ...choice.delta, tool_calls: toolCalls } }
+            : choice);
+        return { ...chunk, choices };
+    }
+    append(call, position) {
+        const id = toolCallId(call);
+        const type = toolCallType(call);
+        const nameFragment = toolCallName(call);
+        const argumentFragment = toolCallArguments(call);
+        const providerMetadata = readProviderMetadata(call);
+        const slot = toolCallSlot(call, position);
+        const key = this.keysByPosition.get(slot) ?? toolCallKey(id, slot);
+        this.keysByPosition.set(slot, key);
+        const current = this.calls.get(key);
+        const name = appendToolFragment(current?.name ?? '', nameFragment, this.knownNames);
+        const args = appendToolArguments(current?.arguments ?? '', argumentFragment);
+        if (current === undefined) {
+            this.calls.set(key, { id, type, name, arguments: args, ...(providerMetadata === undefined ? {} : { providerMetadata }) });
+            this.order.push(key);
+            return;
+        }
+        const nextProviderMetadata = current.providerMetadata ?? providerMetadata;
+        this.calls.set(key, {
+            id: current.id.length === 0 && id.length > 0 ? id : current.id,
+            type: type || current.type,
+            name: current.name + name,
+            arguments: args,
+            ...(nextProviderMetadata === undefined ? {} : { providerMetadata: nextProviderMetadata }),
+        });
+    }
+}
+function readProviderMetadata(value) {
+    if (!isRecord(value))
+        return undefined;
+    const metadata = value['provider_metadata'] ?? value['providerMetadata'];
+    if (isRecord(metadata))
+        return metadata;
+    const signature = value['thoughtSignature'] ?? value['thought_signature'];
+    return typeof signature === 'string' && signature.length > 0
+        ? { google: { thought_signature: signature } }
+        : undefined;
+}
+function toolCallSlot(call, position) {
+    const index = call.index;
+    return typeof index === 'number' && Number.isInteger(index) ? index : position;
+}
+function toolCallKey(id, slot) {
+    return id.length > 0 ? `id:${id}` : `index:${slot}`;
+}
+function toolCallId(call) {
+    const value = call;
+    if (!isRecord(value))
+        return '';
+    return typeof value['id'] === 'string' ? value['id'] : '';
+}
+function toolCallType(call) {
+    const value = call;
+    if (!isRecord(value))
+        return 'function';
+    return typeof value['type'] === 'string' && value['type'].length > 0 ? value['type'] : 'function';
+}
+function toolCallName(call) {
+    const value = call;
+    if (!isRecord(value))
+        return '';
+    return isRecord(value['function']) && typeof value['function']['name'] === 'string' ? value['function']['name'] : '';
+}
+function toolCallArguments(call) {
+    const value = call;
+    if (!isRecord(value))
+        return '';
+    return isRecord(value['function']) && typeof value['function']['arguments'] === 'string' ? value['function']['arguments'] : '';
+}
+function appendToolFragment(emitted, fragment, knownNames) {
+    if (fragment.length === 0)
+        return '';
+    if (fragment === emitted)
+        return '';
+    if (knownNames !== undefined && knownNames.has(fragment) && fragment.startsWith(emitted))
+        return fragment.slice(emitted.length);
+    if (fragment.startsWith(emitted) && emitted.length > 0)
+        return fragment.slice(emitted.length);
+    return fragment;
+}
+function appendToolArguments(emitted, fragment) {
+    if (fragment.length === 0)
+        return emitted;
+    if (emitted.length === 0 || fragment === emitted)
+        return emitted.length === 0 ? fragment : emitted;
+    if (fragment.startsWith(emitted))
+        return fragment;
+    const mergedObject = mergeJsonObjectFragments(emitted, fragment);
+    if (mergedObject !== undefined)
+        return mergedObject;
+    return emitted + fragment;
+}
+function mergeJsonObjectFragments(emitted, fragment) {
+    if (emitted.length === 0 || fragment.length === 0)
+        return undefined;
+    const current = parseJsonObject(emitted);
+    const next = parseJsonObject(fragment);
+    if (current === undefined || next === undefined)
+        return undefined;
+    return JSON.stringify({ ...current, ...next });
+}
+function parseJsonObject(value) {
+    try {
+        const parsed = JSON.parse(value);
+        return isRecord(parsed) ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function recordToolCalls(chunk, ids, names) {
+    for (const call of chunk.choices[0]?.delta.tool_calls ?? []) {
+        const id = toolCallId(call);
+        const name = toolCallName(call);
+        if (id.length > 0)
+            ids.add(id);
+        if (name.length > 0)
+            names.add(name);
+    }
+}
+function getToolNames(tool) {
+    if ('function' in tool && typeof tool.function.name === 'string')
+        return [tool.function.name];
+    if ('name' in tool && typeof tool.name === 'string')
+        return [tool.name];
+    if ('functionDeclarations' in tool)
+        return tool.functionDeclarations.flatMap((declaration) => typeof declaration.name === 'string' ? [declaration.name] : []);
+    return [];
+}
+function normalizeCompletionResponse(response) {
+    return {
+        ...response,
+        choices: response.choices.map((choice) => ({
+            ...choice,
+            message: normalizeAssistantMessage(choice.message),
+        })),
+    };
+}
+function normalizeAssistantMessage(message) {
+    const rawMessage = message;
+    const providerToolCalls = [
+        ...(Array.isArray(message.content) ? extractProviderToolCalls(message.content) : []),
+        ...extractLegacyFunctionCall(rawMessage['function_call'], 0),
+    ];
+    if (!Array.isArray(message.content) && providerToolCalls.length === 0)
+        return message;
+    return {
+        ...message,
+        ...(Array.isArray(message.content) ? { content: textContent(message.content) } : {}),
+        ...(providerToolCalls.length === 0 ? {} : { tool_calls: [...(message.tool_calls ?? []), ...providerToolCalls] }),
+    };
+}
+function extractProviderToolCalls(content) {
+    const calls = [];
+    for (const [index, part] of content.entries()) {
+        if (typeof part !== 'object' || part === null)
+            continue;
+        if ('functionCall' in part && isRecord(part.functionCall) && typeof part.functionCall['name'] === 'string') {
+            const args = part.functionCall['args'];
+            calls.push({
+                id: typeof part.functionCall['id'] === 'string' && part.functionCall['id'].length > 0 ? part.functionCall['id'] : `provider-call-${index}`,
+                type: 'function',
+                function: { name: part.functionCall['name'], arguments: serializeToolArguments(args) },
+                ...(readProviderMetadata(part) === undefined ? {} : { provider_metadata: readProviderMetadata(part) }),
+            });
+            continue;
+        }
+        if ('tool_use' in part && isRecord(part.tool_use) && typeof part.tool_use['name'] === 'string') {
+            const input = part.tool_use['input'];
+            calls.push({
+                id: typeof part.tool_use['id'] === 'string' && part.tool_use['id'].length > 0 ? part.tool_use['id'] : `provider-call-${index}`,
+                type: 'function',
+                function: { name: part.tool_use['name'], arguments: JSON.stringify(input ?? {}) },
+                ...(readProviderMetadata(part) === undefined ? {} : { provider_metadata: readProviderMetadata(part) }),
+            });
+        }
+    }
+    return calls;
+}
+function extractLegacyFunctionCall(value, index) {
+    if (!isRecord(value) || typeof value['name'] !== 'string')
+        return [];
+    const args = value['arguments'];
+    return [{
+            id: typeof value['id'] === 'string' && value['id'].length > 0 ? value['id'] : `provider-call-${index}`,
+            type: 'function',
+            function: { name: value['name'], arguments: serializeToolArguments(args) },
+            ...(readProviderMetadata(value) === undefined ? {} : { provider_metadata: readProviderMetadata(value) }),
+        }];
+}
+function serializeToolArguments(value) {
+    if (value === undefined)
+        return '';
+    if (typeof value === 'string')
+        return value;
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return '';
+    }
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+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.reduce((result, part) => {
+        if (typeof part !== 'object' || part === null || !('text' in part))
+            return result;
+        const text = part.text;
+        return result + (typeof text === 'string' ? text : '');
+    }, '');
+}
+function textLength(content) {
+    if (typeof content === 'string')
+        return content.length;
+    if (!Array.isArray(content))
+        return 0;
+    return content.reduce((total, part) => {
+        if (typeof part !== 'object' || part === null || !('text' in part))
+            return total;
+        const text = part.text;
+        return total + (typeof text === 'string' ? text.length : 0);
+    }, 0);
+}
+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 } : {}),
+    };
+}

package/dist/infrastructure/cache/cache-policy.d.ts

@@ -0,0 +1,7 @@
+export interface CachePolicy {
+    enabled: boolean;
+    modelCatalogTtlMs: number;
+    maxEntryBytes: number;
+    maxTotalBytes: number;
+}
+export declare function resolveCachePolicy(env?: Readonly<Record<string, string | undefined>>): CachePolicy;

package/dist/infrastructure/cache/cache-policy.js

@@ -0,0 +1,18 @@
+export function resolveCachePolicy(env = process.env) {
+    return {
+        enabled: parseBoolean(env['LOTAGATE_CACHE_ENABLED'], true),
+        modelCatalogTtlMs: readBoundedEnvironmentInteger(env['LOTAGATE_MODEL_CACHE_TTL_SECONDS'], 300, 1, 86_400) * 1_000,
+        maxEntryBytes: readBoundedEnvironmentInteger(env['LOTAGATE_CACHE_MAX_ENTRY_BYTES'], 5 * 1024 * 1024, 1_024, 50 * 1024 * 1024),
+        maxTotalBytes: readBoundedEnvironmentInteger(env['LOTAGATE_CACHE_MAX_BYTES'], 50 * 1024 * 1024, 1 * 1024 * 1024, 500 * 1024 * 1024),
+    };
+}
+function parseBoolean(value, fallback) {
+    if (value === undefined)
+        return fallback;
+    if (value.trim().toLowerCase() === 'true')
+        return true;
+    if (value.trim().toLowerCase() === 'false')
+        return false;
+    return fallback;
+}
+import { readBoundedEnvironmentInteger } from '../config/environment-values.js';

package/dist/infrastructure/cache/file-cache-store.d.ts

@@ -0,0 +1,17 @@
+import type { CacheStore, CacheWriteOptions } from '../../ports/cache-store.js';
+import type { CachePolicy } from './cache-policy.js';
+export declare class FileCacheStore implements CacheStore {
+    private readonly root;
+    private readonly policy;
+    private readonly now;
+    private prunePromise;
+    constructor(root: string, policy: CachePolicy, now?: () => number);
+    get<T>(namespace: string, key: string): Promise<T | undefined>;
+    set<T>(namespace: string, key: string, value: T, options: CacheWriteOptions): Promise<void>;
+    delete(namespace: string, key: string): Promise<void>;
+    clear(namespace?: string): Promise<void>;
+    prune(): Promise<void>;
+    private schedulePrune;
+    private namespacePath;
+    private filePath;
+}

package/dist/infrastructure/cache/file-cache-store.js

@@ -0,0 +1,121 @@
+import crypto from 'node:crypto';
+import fsSync from 'node:fs';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { atomicWriteFile, withFileLock } from '../filesystem/atomic-file-store.js';
+import { isFileNotFound } from '../filesystem/fs-errors.js';
+import { readJsonFileBounded } from '../filesystem/bounded-json-reader.js';
+export class FileCacheStore {
+    root;
+    policy;
+    now;
+    prunePromise;
+    constructor(root, policy, now = Date.now) {
+        this.root = root;
+        this.policy = policy;
+        this.now = now;
+        try {
+            fsSync.mkdirSync(root, { recursive: true, mode: 0o700 });
+        }
+        catch { /* Cache is best effort and must not block CLI startup. */ }
+    }
+    async get(namespace, key) {
+        if (!this.policy.enabled)
+            return undefined;
+        const filePath = this.filePath(namespace, key);
+        try {
+            const envelope = await readJsonFileBounded(filePath, this.policy.maxEntryBytes);
+            if (envelope.schemaVersion !== 1 || envelope.namespace !== namespace || envelope.keyHash !== hashKey(namespace, key) || typeof envelope.expiresAt !== 'string')
+                return undefined;
+            if (Date.parse(envelope.expiresAt) <= this.now()) {
+                await this.delete(namespace, key);
+                return undefined;
+            }
+            return envelope.value;
+        }
+        catch (error) {
+            if (!isFileNotFound(error))
+                await this.delete(namespace, key).catch(() => undefined);
+            return undefined;
+        }
+    }
+    async set(namespace, key, value, options) {
+        if (!this.policy.enabled || options.ttlMs <= 0)
+            return;
+        const envelope = {
+            schemaVersion: 1,
+            namespace,
+            keyHash: hashKey(namespace, key),
+            createdAt: new Date(this.now()).toISOString(),
+            expiresAt: new Date(this.now() + options.ttlMs).toISOString(),
+            value,
+        };
+        const data = `${JSON.stringify(envelope)}\n`;
+        if (Buffer.byteLength(data, 'utf8') > this.policy.maxEntryBytes)
+            return;
+        const filePath = this.filePath(namespace, key);
+        await withFileLock(filePath, () => atomicWriteFile(filePath, data));
+        this.schedulePrune();
+    }
+    async delete(namespace, key) {
+        await fs.rm(this.filePath(namespace, key), { force: true });
+    }
+    async clear(namespace) {
+        await fs.rm(namespace === undefined ? this.root : this.namespacePath(namespace), { recursive: true, force: true });
+    }
+    async prune() {
+        if (!this.policy.enabled)
+            return;
+        const files = await listFiles(this.root);
+        const entries = [];
+        for (const filePath of files) {
+            try {
+                const stat = await fs.stat(filePath);
+                const value = await readJsonFileBounded(filePath, this.policy.maxEntryBytes);
+                if (value.schemaVersion !== 1 || typeof value.expiresAt !== 'string' || Date.parse(value.expiresAt) <= this.now()) {
+                    await fs.rm(filePath, { force: true });
+                    continue;
+                }
+                entries.push({ filePath, size: stat.size, modifiedAt: stat.mtimeMs });
+            }
+            catch {
+                await fs.rm(filePath, { force: true });
+            }
+        }
+        let total = entries.reduce((sum, entry) => sum + entry.size, 0);
+        for (const entry of entries.sort((left, right) => left.modifiedAt - right.modifiedAt)) {
+            if (total <= this.policy.maxTotalBytes)
+                break;
+            await fs.rm(entry.filePath, { force: true });
+            total -= entry.size;
+        }
+    }
+    schedulePrune() {
+        if (this.prunePromise !== undefined)
+            return;
+        this.prunePromise = this.prune().catch(() => undefined).finally(() => { this.prunePromise = undefined; });
+    }
+    namespacePath(namespace) { return path.join(this.root, encodeNamespace(namespace)); }
+    filePath(namespace, key) { return path.join(this.namespacePath(namespace), `${hashKey(namespace, key)}.json`); }
+}
+function hashKey(namespace, key) { return crypto.createHash('sha256').update(`${namespace}\0${key}`).digest('hex'); }
+function encodeNamespace(namespace) { return Buffer.from(namespace, 'utf8').toString('base64url'); }
+async function listFiles(root) {
+    try {
+        const entries = await fs.readdir(root, { withFileTypes: true });
+        const files = [];
+        for (const entry of entries) {
+            const candidate = path.join(root, entry.name);
+            if (entry.isDirectory())
+                files.push(...await listFiles(candidate));
+            else if (entry.isFile() && entry.name.endsWith('.json'))
+                files.push(candidate);
+        }
+        return files;
+    }
+    catch (error) {
+        if (isFileNotFound(error))
+            return [];
+        throw error;
+    }
+}

package/dist/infrastructure/clipboard/clipboard-adapter-factory.d.ts

@@ -0,0 +1,11 @@
+import type { ClipboardAdapter, ClipboardImage } from '../../ports/clipboard-adapter.js';
+import { type HostPlatformContext } from '../platform/host-platform.js';
+export declare function createClipboardAdapter(platform?: HostPlatformContext): ClipboardAdapter;
+export declare class ProcessClipboardAdapter implements ClipboardAdapter {
+    private readonly command;
+    private readonly args;
+    private readonly mimeType;
+    private readonly platform;
+    constructor(command: string, args: readonly string[], mimeType: string, platform?: HostPlatformContext);
+    readImage(): Promise<ClipboardImage | undefined>;
+}