dexto 1.14.5 → 2.0.0-beta.0

package/dist/cli/cloud/commands/files.js

@@ -0,0 +1,282 @@
+// `cloud files`: upload, download, share and delete the project's files.
+import { createHash } from 'node:crypto';
+import { createReadStream, createWriteStream, openAsBlob } from 'node:fs';
+import { stat } from 'node:fs/promises';
+import path from 'node:path';
+import { Writable } from 'node:stream';
+import { unwrap } from '@dexto/cloud-client';
+import { argument, CommandFailure, flag, integerOption, PAGE_OPTIONS, pageQuery, requireConsent, stringOption, UsageError, YES_OPTION, } from '../command.js';
+import { sendV1, v1Failure } from '../v1.js';
+/** Larger files go up in parts, through an upload session. */
+const ONE_REQUEST_MAX_BYTES = 80 * 1024 * 1024;
+const COLUMNS = [
+    { header: 'id', value: (file) => file.id },
+    { header: 'path', value: (file) => file.path },
+    { header: 'size', value: (file) => formatBytes(file.size_bytes) },
+    { header: 'type', value: (file) => file.content_type },
+    { header: 'updated', value: (file) => file.updated_at },
+];
+const list = {
+    options: {
+        ...PAGE_OPTIONS,
+        contains: { description: 'Only paths containing this text.', type: 'string' },
+        prefix: { description: 'Only paths starting with this, such as reports/.', type: 'string' },
+    },
+    path: ['cloud', 'files', 'list'],
+    summary: "List the project's files.",
+    async run(context, input) {
+        const prefix = stringOption(input, 'prefix');
+        const contains = stringOption(input, 'contains');
+        const page = await unwrap(await (await context.client()).GET('/v1/files', {
+            params: {
+                query: {
+                    ...pageQuery(input),
+                    ...(prefix === undefined ? {} : { prefix }),
+                    ...(contains === undefined ? {} : { contains }),
+                },
+            },
+        }));
+        context.output.list(page, COLUMNS);
+    },
+};
+const get = {
+    arguments: '<file>',
+    path: ['cloud', 'files', 'get'],
+    summary: 'Show a file by id or path.',
+    async run(context, input) {
+        const client = await context.client();
+        context.output.record(await getFile(client, await resolveFileId(client, argument(input, 0, 'file'))));
+    },
+};
+const upload = {
+    arguments: '<local_path> [path]',
+    options: {
+        'content-type': {
+            description: 'The media type (default from the extension).',
+            type: 'string',
+        },
+        'expires-at': {
+            description: 'Delete the file at this ISO 8601 time.',
+            type: 'string',
+            valueName: 'TIME',
+        },
+        overwrite: { description: 'Replace a file already at the path.', type: 'boolean' },
+    },
+    path: ['cloud', 'files', 'upload'],
+    summary: 'Upload a local file to a project path (default: its file name).',
+    async run(context, input) {
+        const localPath = argument(input, 0, 'local_path');
+        if (!(await stat(localPath).catch(() => null))?.isFile())
+            throw new UsageError(`${localPath} is not a file.`);
+        const body = await openAsBlob(localPath).catch((error) => {
+            throw new UsageError(`Cannot read ${localPath}: ${error instanceof Error ? error.message : 'unknown error'}.`);
+        });
+        const expiresAt = stringOption(input, 'expires-at');
+        const file = await uploadFile(context, {
+            body,
+            contentType: stringOption(input, 'content-type') ?? contentTypeFor(localPath),
+            expiresAt: expiresAt ?? null,
+            overwrite: flag(input, 'overwrite'),
+            path: input.positionals[1] ?? path.basename(localPath),
+            sha256: await hashFile(localPath),
+        });
+        context.output.result(file, `Uploaded ${file.path} (${formatBytes(file.size_bytes)}, ${file.id}).`);
+    },
+};
+const download = {
+    arguments: '<file> [local_path]',
+    path: ['cloud', 'files', 'download'],
+    summary: 'Download a file by id or path to a local path (default: its file name), or - for stdout.',
+    async run(context, input) {
+        const client = await context.client();
+        const fileId = await resolveFileId(client, argument(input, 0, 'file'));
+        const file = await getFile(client, fileId);
+        const target = input.positionals[1] ?? path.basename(file.path);
+        const { data, response } = await client.GET('/v1/files/{file_id}/content', {
+            params: { path: { file_id: fileId } },
+            parseAs: 'stream',
+        });
+        if (!response.ok || data === undefined || data === null)
+            throw v1Failure(context, response.status, await response.text().catch(() => ''));
+        if (target === '-') {
+            const reader = data.getReader();
+            for (let chunk = await reader.read(); !chunk.done; chunk = await reader.read())
+                await context.runtime.writeBytes(chunk.value);
+            return;
+        }
+        await data.pipeTo(Writable.toWeb(createWriteStream(target)));
+        context.output.result({ ...file, local_path: target }, `Saved ${file.path} to ${target}.`);
+    },
+};
+const url = {
+    arguments: '<file>',
+    options: {
+        'expires-in': {
+            description: 'Seconds the URL works, up to 86400 (default 3600).',
+            type: 'string',
+            valueName: 'SECONDS',
+        },
+    },
+    path: ['cloud', 'files', 'url'],
+    summary: 'Create a URL anyone can read the file from until it expires.',
+    async run(context, input) {
+        const client = await context.client();
+        const expiresIn = integerOption(input, 'expires-in');
+        const result = await unwrap(await client.POST('/v1/files/{file_id}/url', {
+            params: {
+                path: { file_id: await resolveFileId(client, argument(input, 0, 'file')) },
+            },
+            body: expiresIn === undefined ? {} : { expires_in: expiresIn },
+        }));
+        context.output.result(result, result.url);
+    },
+};
+const remove = {
+    arguments: '<file>',
+    options: YES_OPTION,
+    path: ['cloud', 'files', 'delete'],
+    summary: 'Delete a file by id or path.',
+    async run(context, input) {
+        await requireConsent(context, flag(input, 'yes'), `Deleting ${argument(input, 0, 'file')} can't be undone.`);
+        const client = await context.client();
+        const result = await unwrap(await client.DELETE('/v1/files/{file_id}', {
+            params: {
+                path: { file_id: await resolveFileId(client, argument(input, 0, 'file')) },
+            },
+        }));
+        context.output.result(result, `Deleted file ${result.id}.`);
+    },
+};
+async function getFile(client, fileId) {
+    return await unwrap(await client.GET('/v1/files/{file_id}', { params: { path: { file_id: fileId } } }));
+}
+/**
+ * Uploads a file: in one request up to 80 MiB, otherwise in parts through an upload session,
+ * aborted when a part fails.
+ */
+export async function uploadFile(context, upload) {
+    if (upload.body.size <= ONE_REQUEST_MAX_BYTES) {
+        const query = new URLSearchParams({ path: upload.path });
+        if (upload.overwrite)
+            query.set('overwrite', 'true');
+        if (upload.expiresAt !== null)
+            query.set('expires_at', upload.expiresAt);
+        const response = await sendV1(context, 'POST', `/v1/files?${query}`, {
+            body: upload.body,
+            headers: {
+                accept: 'application/json',
+                'content-type': upload.contentType,
+                'content-length': String(upload.body.size),
+                'x-content-sha256': upload.sha256,
+            },
+        });
+        const text = await response.text();
+        if (!response.ok)
+            throw v1Failure(context, response.status, text);
+        return JSON.parse(text);
+    }
+    const client = await context.client();
+    const session = await unwrap(await client.POST('/v1/files/uploads', {
+        body: {
+            content_type: upload.contentType,
+            overwrite: upload.overwrite,
+            path: upload.path,
+            sha256: upload.sha256,
+            size_bytes: upload.body.size,
+            ...(upload.expiresAt === null ? {} : { expires_at: upload.expiresAt }),
+        },
+    }));
+    const params = { params: { path: { upload_id: session.id } } };
+    try {
+        if (session.upload_url === null)
+            throw new CommandFailure('failed', 'The upload session has no upload URL.', null);
+        // `parts` lists the parts already uploaded; send every other one of `part_count`.
+        const uploaded = new Set(session.parts.map((part) => part.part_number));
+        for (let partNumber = 1; partNumber <= session.part_count; partNumber += 1) {
+            if (uploaded.has(partNumber))
+                continue;
+            const start = (partNumber - 1) * session.part_size_bytes;
+            const response = await context.runtime.fetch(`${session.upload_url}/${partNumber}`, {
+                body: upload.body.slice(start, Math.min(start + session.part_size_bytes, session.size_bytes)),
+                method: 'PUT',
+                signal: context.runtime.signal,
+            });
+            if (!response.ok)
+                throw new CommandFailure('failed', `Part ${partNumber} of the upload was refused (HTTP ${response.status}).`, null);
+        }
+        return await unwrap(await client.POST('/v1/files/uploads/{upload_id}/complete', params));
+    }
+    catch (error) {
+        await client.POST('/v1/files/uploads/{upload_id}/abort', params).catch(() => undefined);
+        throw error;
+    }
+}
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/iu;
+/**
+ * A file id as given, or the id of the file at a path. The API addresses files only by id, so a
+ * path is found by listing its prefix.
+ */
+async function resolveFileId(client, file) {
+    if (UUID.test(file))
+        return file;
+    let after;
+    for (;;) {
+        const page = await unwrap(await client.GET('/v1/files', {
+            params: {
+                query: { limit: 1000, prefix: file, ...(after === undefined ? {} : { after }) },
+            },
+        }));
+        const match = page.data.find((each) => each.path === file);
+        if (match !== undefined)
+            return match.id;
+        if (!page.has_more || page.next_after === null)
+            break;
+        after = page.next_after;
+    }
+    throw new CommandFailure('not_found', `No file at ${file}.`, null);
+}
+/** A local file's SHA-256, hex, read as a stream. */
+export async function hashFile(localPath) {
+    const hash = createHash('sha256');
+    for await (const chunk of createReadStream(localPath))
+        hash.update(chunk);
+    return hash.digest('hex');
+}
+const CONTENT_TYPES = {
+    '.csv': 'text/csv',
+    '.gif': 'image/gif',
+    '.html': 'text/html',
+    '.jpeg': 'image/jpeg',
+    '.jpg': 'image/jpeg',
+    '.json': 'application/json',
+    '.m4v': 'video/mp4',
+    '.md': 'text/markdown',
+    '.mov': 'video/quicktime',
+    '.mp3': 'audio/mpeg',
+    '.mp4': 'video/mp4',
+    '.pdf': 'application/pdf',
+    '.png': 'image/png',
+    '.svg': 'image/svg+xml',
+    '.txt': 'text/plain',
+    '.wav': 'audio/wav',
+    '.webm': 'video/webm',
+    '.webp': 'image/webp',
+    '.zip': 'application/zip',
+};
+/** The media type for a local file, by its extension. */
+export function contentTypeFor(localPath) {
+    return CONTENT_TYPES[path.extname(localPath).toLowerCase()] ?? 'application/octet-stream';
+}
+export function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    const units = ['KiB', 'MiB', 'GiB'];
+    let value = bytes / 1024;
+    let unit = 0;
+    while (value >= 1024 && unit < units.length - 1) {
+        value /= 1024;
+        unit += 1;
+    }
+    return `${value.toFixed(1)} ${units[unit]}`;
+}
+export const fileCommands = [list, get, upload, download, url, remove];

package/dist/cli/cloud/commands/find.d.ts

@@ -0,0 +1,3 @@
+import { type Command } from '../command.js';
+export declare const findCommands: readonly Command[];
+//# sourceMappingURL=find.d.ts.map

package/dist/cli/cloud/commands/find.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find.d.ts","sourceRoot":"","sources":["../../../../src/cli/cloud/commands/find.ts"],"names":[],"mappings":"AAEA,OAAO,EAA2C,KAAK,OAAO,EAAE,MAAM,eAAe,CAAC;AAmFtF,eAAO,MAAM,YAAY,EAAE,SAAS,OAAO,EAAW,CAAC"}

package/dist/cli/cloud/commands/find.js

@@ -0,0 +1,63 @@
+// `find`: what to run for something you want to do, from Dexto's search, as commands.
+import { integerOption, isJsonObject, UsageError } from '../command.js';
+import { commandForCall } from './workspace-apps.js';
+import { listWorkspaceTools, queryWorkspaceTool } from './workspace.js';
+const find = {
+    arguments: '<what...>',
+    options: {
+        limit: {
+            description: 'How many to show (default 5, up to 8).',
+            type: 'string',
+            valueName: 'N',
+        },
+    },
+    path: ['find'],
+    summary: "Find what to run for something you want to do: Dexto's operations, apps, skills, agents and more, each as a command.",
+    async run(context, input) {
+        const query = input.positionals.join(' ').trim();
+        if (query.length < 2)
+            throw new UsageError('Say what you want to do, such as: dexto find "share a file".');
+        const limit = integerOption(input, 'limit');
+        const page = await queryWorkspaceTool(context, 'dexto_search', {
+            query,
+            ...(limit === undefined ? {} : { limit }),
+        });
+        const results = isJsonObject(page) && Array.isArray(page.results)
+            ? page.results.filter(isJsonObject)
+            : [];
+        const tools = await listWorkspaceTools(context);
+        const operationsByApp = new Map();
+        const found = [];
+        for (const result of results) {
+            const call = isJsonObject(result.call) && typeof result.call.tool === 'string'
+                ? {
+                    arguments: isJsonObject(result.call.arguments)
+                        ? result.call.arguments
+                        : {},
+                    tool: result.call.tool,
+                }
+                : null;
+            found.push({
+                availability: String(result.availability ?? ''),
+                command: call === null
+                    ? null
+                    : await commandForCall(context, tools, call, operationsByApp),
+                kind: String(result.sourceKind ?? ''),
+                next_step: String(result.nextStep ?? ''),
+                summary: String(result.summary ?? ''),
+                title: String(result.title ?? ''),
+            });
+        }
+        if (context.output.json)
+            return context.output.list({ data: found }, []);
+        if (found.length === 0) {
+            context.runtime.writeOutput('Nothing found. Try other words, or run dexto workspace for your apps.\n');
+            return;
+        }
+        context.runtime.writeOutput(found
+            .map((each, index) => `${index + 1}. ${each.title} (${each.kind})\n   ${each.command ?? each.next_step}\n`)
+            .join(''));
+        context.output.note('Fill in each <value>, and run a command with --help for its input.');
+    },
+};
+export const findCommands = [find];

package/dist/cli/cloud/commands/models.d.ts

@@ -0,0 +1,3 @@
+import { type Command } from '../command.js';
+export declare const modelCommands: readonly Command[];
+//# sourceMappingURL=models.d.ts.map

package/dist/cli/cloud/commands/models.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"models.d.ts","sourceRoot":"","sources":["../../../../src/cli/cloud/commands/models.ts"],"names":[],"mappings":"AAIA,OAAO,EAYH,KAAK,OAAO,EAGf,MAAM,eAAe,CAAC;AA4UvB,eAAO,MAAM,aAAa,EAAE,SAAS,OAAO,EAAmC,CAAC"}

package/dist/cli/cloud/commands/models.js

@@ -0,0 +1,248 @@
+// `cloud models`: every model call, text or media, as a model id and its input.
+import { randomUUID } from 'node:crypto';
+import { unwrap } from '@dexto/cloud-client';
+import { argument, BODY_OPTIONS, CommandFailure, flag, isJsonObject, PAGE_OPTIONS, pageQuery, readJsonBody, requireConsent, stringOption, UsageError, } from '../command.js';
+const KINDS = ['text', 'image', 'video', 'audio', 'file'];
+const MODEL_COLUMNS = [
+    { header: 'id', value: (model) => model.id },
+    { header: 'kind', value: (model) => model.kind },
+    { header: 'title', value: (model) => ('media' in model ? model.media.title : model.text.name) },
+    { header: 'price', value: (model) => price(model) },
+];
+const RUN_COLUMNS = [
+    { header: 'id', value: (run) => run.id },
+    { header: 'model', value: (run) => run.model },
+    { header: 'kind', value: (run) => run.media_kind },
+    { header: 'status', value: (run) => run.status },
+    { header: 'created', value: (run) => run.created_at },
+];
+const list = {
+    options: {
+        for: {
+            description: 'Recommend media models for what you want to make.',
+            type: 'string',
+            valueName: 'INTENT',
+        },
+        type: {
+            description: `Only models of this kind: ${KINDS.join(', ')}.`,
+            type: 'string',
+            valueName: 'KIND',
+        },
+    },
+    path: ['cloud', 'models', 'list'],
+    summary: 'List the models you can run, text and media, with their prices.',
+    async run(context, input) {
+        const type = stringOption(input, 'type');
+        if (type !== undefined && !KINDS.some((kind) => kind === type))
+            throw new UsageError(`--type must be one of ${KINDS.join(', ')}.`);
+        const intent = stringOption(input, 'for');
+        const client = await context.client();
+        const models = intent === undefined
+            ? await catalog(client, type === undefined ? 'both' : type === 'text' ? 'text' : 'media')
+            : (await unwrap(await client.GET('/v1/media/recommendations', {
+                params: { query: { intent } },
+            }))).data.map(mediaModel);
+        context.output.list({ data: models.filter((model) => type === undefined || model.kind === type) }, MODEL_COLUMNS);
+    },
+};
+const get = {
+    arguments: '<model>',
+    path: ['cloud', 'models', 'get'],
+    summary: 'Show a model: its kind, price, and what it takes.',
+    async run(context, input) {
+        const model = await findModel(await context.client(), argument(input, 0, 'model'));
+        if (context.output.json)
+            return context.output.record('media' in model ? model.media : model.text);
+        if (!('media' in model)) {
+            const capabilities = model.text.capabilities;
+            const longContext = model.text.pricing?.contextOver200kPerM ?? null;
+            return context.output.record({
+                id: model.id,
+                kind: model.kind,
+                price: price(model),
+                ...(longContext === null
+                    ? {}
+                    : {
+                        long_prompt_price: `$${longContext.inputPerM} in / $${longContext.outputPerM} out per 1M tokens above ${longContext.inputTokensAbove} input tokens`,
+                    }),
+                context_tokens: capabilities.maxInputTokens,
+                input: capabilities.input.join(', '),
+                output: capabilities.output.join(', '),
+                reasoning: capabilities.reasoning,
+                tools: capabilities.supportsToolCall,
+            });
+        }
+        const required = new Set(model.media.input.required);
+        context.output.record({
+            id: model.id,
+            kind: model.kind,
+            title: model.media.title,
+            description: model.media.description,
+            price: price(model),
+            input: model.media.input.fields
+                .map((field) => `${field.name}${required.has(field.name) ? '*' : ''} (${field.type})`)
+                .join(', '),
+        });
+    },
+};
+const run = {
+    arguments: '<model> [prompt...]',
+    options: {
+        ...BODY_OPTIONS,
+        'no-wait': {
+            description: 'Start a media run and print its id instead of waiting for it.',
+            type: 'boolean',
+        },
+        overwrite: {
+            description: 'With --save-to, replace a file already there.',
+            type: 'boolean',
+        },
+        'save-to': {
+            description: "Keep a media run's outputs as project files: a path, or a prefix ending in /.",
+            type: 'string',
+            valueName: 'PATH',
+        },
+        system: { description: 'A system prompt, for a text model.', type: 'string' },
+        yes: {
+            description: 'Run a media model without confirming its estimated price. Pass it only once your person has agreed.',
+            type: 'boolean',
+        },
+    },
+    path: ['cloud', 'models', 'run'],
+    summary: 'Run any model. A text model replies to the prompt (or stdin); a media model is priced, confirmed, then run.',
+    async run(context, input) {
+        const client = await context.client();
+        const model = await findModel(client, argument(input, 0, 'model'));
+        const prompt = input.positionals.slice(1).join(' ').trim();
+        return 'media' in model
+            ? await runMedia(context, input, client, model.id, prompt)
+            : await runText(context, input, client, model.id, prompt);
+    },
+};
+const runs = {
+    options: PAGE_OPTIONS,
+    path: ['cloud', 'models', 'runs', 'list'],
+    summary: 'List recent media runs in the Cloud project.',
+    async run(context, input) {
+        context.output.list(await unwrap(await (await context.client()).GET('/v1/media/generations', {
+            params: { query: pageQuery(input) },
+        })), RUN_COLUMNS);
+    },
+};
+const runGet = {
+    arguments: '<run_id>',
+    path: ['cloud', 'models', 'runs', 'get'],
+    summary: 'Show a media run, its status and its outputs.',
+    async run(context, input) {
+        context.output.record(await getRun(await context.client(), argument(input, 0, 'run_id')));
+    },
+};
+async function getRun(client, id) {
+    return await unwrap(await client.GET('/v1/media/generations/{generation_id}', {
+        params: { path: { generation_id: id } },
+    }));
+}
+async function runText(context, input, client, model, argumentPrompt) {
+    if (stringOption(input, 'data') !== undefined || stringOption(input, 'file') !== undefined)
+        throw new UsageError(`${model} is a text model: give it a prompt, not --data or --file.`);
+    // A prompt piped in, such as a file to summarise, when none is given as arguments.
+    const prompt = argumentPrompt.length > 0 || context.runtime.prompt !== null
+        ? argumentPrompt
+        : (await context.runtime.readStdin()).trim();
+    if (prompt.length === 0)
+        throw new UsageError('Give the prompt as arguments, or pipe it on stdin.');
+    const system = stringOption(input, 'system');
+    const response = await unwrap(await client.POST('/v1/chat/completions', {
+        body: {
+            model,
+            messages: [
+                ...(system === undefined ? [] : [{ role: 'system', content: system }]),
+                { role: 'user', content: prompt },
+            ],
+        },
+    }));
+    if (context.output.jsonContent)
+        return context.output.record(response);
+    // The operation also answers as a stream; without `stream` it is always the JSON reply.
+    if (typeof response !== 'object' || response === null || !('choices' in response))
+        throw new CommandFailure('failed', `${model} answered without a reply.`, null);
+    const content = response.choices[0]?.message.content;
+    context.runtime.writeOutput(`${typeof content === 'string' ? content : JSON.stringify(content ?? null)}\n`);
+}
+async function runMedia(context, input, client, model, prompt) {
+    if (stringOption(input, 'system') !== undefined)
+        throw new UsageError(`${model} is a media model: --system is for text models.`);
+    const body = await readJsonBody(context, input);
+    if (body !== null && !isJsonObject(body))
+        throw new UsageError("The model's input must be a JSON object.");
+    const modelInput = {
+        ...(isJsonObject(body) ? body : {}),
+        ...(prompt.length === 0 ? {} : { prompt }),
+    };
+    if (Object.keys(modelInput).length === 0)
+        throw new UsageError("Give the model's input as a prompt, --data or --file.");
+    const estimate = await unwrap(await client.POST('/v1/media/estimates', { body: { input: modelInput, model } }));
+    context.output.note(`Estimated $${estimate.amount_usd} (${estimate.confidence}): ${estimate.explanation}`);
+    await requireConsent(context, flag(input, 'yes'), `Running ${model} spends about $${estimate.amount_usd} of credits.`);
+    const saveTo = stringOption(input, 'save-to');
+    let generation = await unwrap(await client.POST('/v1/media/generations', {
+        params: { header: { 'Idempotency-Key': randomUUID() } },
+        body: {
+            estimate_id: estimate.id,
+            ...(saveTo === undefined
+                ? {}
+                : { overwrite: flag(input, 'overwrite'), save_to: saveTo }),
+        },
+    }));
+    if (flag(input, 'no-wait'))
+        return context.output.result(generation, `Started run ${generation.id}. Check it with dexto cloud models runs get ${generation.id}.`);
+    while (!generation.completed) {
+        await context.runtime.sleep(2000);
+        generation = await getRun(client, generation.id);
+    }
+    if (generation.error !== null)
+        throw new CommandFailure('failed', `Run ${generation.id} failed: ${generation.error.message}`, null);
+    if (context.output.json)
+        return context.output.record(generation);
+    context.runtime.writeOutput(`Run ${generation.id} ${generation.status}.\n`);
+    for (const resource of generation.resources)
+        context.runtime.writeOutput(`${resource.file_path ?? resource.filename ?? resource.id}${resource.url === null ? '' : `  ${resource.url}`}\n`);
+}
+/** The text catalog, the media catalog, or both (text first), as one list. */
+async function catalog(client, which) {
+    const [text, media] = await Promise.all([
+        which === 'media' ? null : unwrap(await client.GET('/v1/models')),
+        which === 'text' ? null : unwrap(await client.GET('/v1/media/models')),
+    ]);
+    return [
+        ...(text?.data ?? []).map((model) => ({
+            id: model.id,
+            kind: 'text',
+            text: model,
+        })),
+        ...(media?.data ?? []).map(mediaModel),
+    ];
+}
+async function findModel(client, id) {
+    const model = (await catalog(client, 'both')).find((each) => each.id === id);
+    if (model === undefined)
+        throw new UsageError(`Unknown model ${id}. List them with dexto cloud models list.`);
+    return model;
+}
+function mediaModel(model) {
+    return { id: model.id, kind: model.media_kind, media: model };
+}
+function price(model) {
+    if (!('media' in model)) {
+        const pricing = model.text.pricing;
+        if (pricing === null)
+            return '-';
+        const base = `$${pricing.inputPerM} in / $${pricing.outputPerM} out per 1M tokens`;
+        return pricing.contextOver200kPerM === null ? base : `${base}, more for long prompts`;
+    }
+    const pricing = model.media.pricing;
+    return pricing.unit_price_usd === undefined
+        ? pricing.estimate_mode
+        : `$${pricing.unit_price_usd}/${pricing.unit}`;
+}
+export const modelCommands = [list, get, run, runs, runGet];

package/dist/cli/cloud/commands/profile.d.ts

@@ -0,0 +1,3 @@
+import { type Command } from '../command.js';
+export declare const profileCommands: readonly Command[];
+//# sourceMappingURL=profile.d.ts.map

package/dist/cli/cloud/commands/profile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"profile.d.ts","sourceRoot":"","sources":["../../../../src/cli/cloud/commands/profile.ts"],"names":[],"mappings":"AAIA,OAAO,EAIH,KAAK,OAAO,EAEf,MAAM,eAAe,CAAC;AAqIvB,eAAO,MAAM,eAAe,EAAE,SAAS,OAAO,EAAkB,CAAC"}