dexto 1.14.6 → 2.0.0-beta.1

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":"AAOA,OAAO,EAUH,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,250 @@
+// `cloud models`: every model call, text or media, as a model id and its input.
+import { CommandFailure } from '../../failure.js';
+import { requireConsent } from '../../interaction.js';
+import { randomUUID } from 'node:crypto';
+import { unwrap } from '@dexto/cloud-client';
+import { argument, BODY_OPTIONS, flag, isJsonObject, PAGE_OPTIONS, pageQuery, readJsonBody, 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":"AAMA,OAAO,EAA4B,KAAK,OAAO,EAAuB,MAAM,eAAe,CAAC;AAqI5F,eAAO,MAAM,eAAe,EAAE,SAAS,OAAO,EAAkB,CAAC"}

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

@@ -0,0 +1,120 @@
+// `profile`: read and change your own Dexto profile, as Settings → Profile does.
+import { CommandFailure } from '../../failure.js';
+import { z } from 'zod';
+import { stringOption, UsageError } from '../command.js';
+import { queryWorkspaceTool } from './workspace.js';
+const ProfileSchema = z.object({
+    bio: z.string().nullable(),
+    displayName: z.string(),
+    handle: z.string(),
+    links: z.array(z.unknown()),
+    showTokenUsage: z.boolean(),
+    visibility: z.enum(['private', 'public']),
+    workEntries: z.array(z.unknown()),
+});
+const get = {
+    path: ['profile', 'get'],
+    summary: 'Show your Dexto profile: handle, name, bio, links, work and whether it is public.',
+    async run(context) {
+        const profile = await readProfile(context, 'dexto_profile_get', {});
+        context.output.result({ profile }, describeProfile(profile));
+    },
+};
+const update = {
+    options: {
+        bio: {
+            description: 'Your bio; "" clears it.',
+            type: 'string',
+            valueName: 'TEXT',
+        },
+        'display-name': { description: 'Your display name.', type: 'string', valueName: 'NAME' },
+        handle: {
+            description: 'Your handle, unique across Dexto: 3 to 30 lowercase letters, digits and hyphens.',
+            type: 'string',
+            valueName: 'HANDLE',
+        },
+        links: {
+            description: 'Your links, replacing them all, as JSON: [{"kind":"github","url":"https://…"}] or {"kind":"custom","label":"…","url":"…"} entries.',
+            type: 'string',
+            valueName: 'JSON',
+        },
+        'token-usage': {
+            description: 'Whether your profile shows your token usage: show or hide.',
+            type: 'string',
+            valueName: 'show|hide',
+        },
+        visibility: {
+            description: 'private, or public for anyone with the link.',
+            type: 'string',
+            valueName: 'private|public',
+        },
+        work: {
+            description: 'Your work entries, replacing them all, as JSON: {"kind":"site","siteId":"…"} or {"kind":"external","title":"…","url":"…","description":null,"imageUrl":null} entries.',
+            type: 'string',
+            valueName: 'JSON',
+        },
+    },
+    path: ['profile', 'update'],
+    summary: 'Change your Dexto profile: only the fields you pass change, such as --handle shaun --visibility public.',
+    async run(context, input) {
+        const changes = profileChanges(input);
+        if (Object.keys(changes).length === 0)
+            throw new UsageError('Pass at least one field to change, such as --handle or --visibility.');
+        const profile = await readProfile(context, 'dexto_profile_update', changes);
+        context.output.result({ profile }, `Updated.\n${describeProfile(profile)}`);
+    },
+};
+/** What `profile update` asks to change, in `dexto_profile_update`'s fields. */
+function profileChanges(input) {
+    const visibility = stringOption(input, 'visibility');
+    if (visibility !== undefined && visibility !== 'private' && visibility !== 'public')
+        throw new UsageError('--visibility must be private or public.');
+    const tokenUsage = stringOption(input, 'token-usage');
+    if (tokenUsage !== undefined && tokenUsage !== 'show' && tokenUsage !== 'hide')
+        throw new UsageError('--token-usage must be show or hide.');
+    const bio = stringOption(input, 'bio');
+    const displayName = stringOption(input, 'display-name');
+    const handle = stringOption(input, 'handle');
+    const links = jsonListOption(input, 'links');
+    const work = jsonListOption(input, 'work');
+    return {
+        ...(bio === undefined ? {} : { bio: bio.trim().length === 0 ? null : bio }),
+        ...(displayName === undefined ? {} : { displayName }),
+        ...(handle === undefined ? {} : { handle }),
+        ...(links === undefined ? {} : { links }),
+        ...(tokenUsage === undefined ? {} : { showTokenUsage: tokenUsage === 'show' }),
+        ...(visibility === undefined ? {} : { visibility }),
+        ...(work === undefined ? {} : { workEntries: work }),
+    };
+}
+/** A JSON list option: every link or work entry at once, replacing what is there. */
+function jsonListOption(input, name) {
+    const value = stringOption(input, name);
+    if (value === undefined)
+        return undefined;
+    let parsed;
+    try {
+        parsed = JSON.parse(value);
+    }
+    catch {
+        throw new UsageError(`--${name} must be a JSON list.`);
+    }
+    if (!Array.isArray(parsed))
+        throw new UsageError(`--${name} must be a JSON list.`);
+    return parsed;
+}
+async function readProfile(context, tool, input) {
+    const value = await queryWorkspaceTool(context, tool, input);
+    const parsed = z.object({ profile: ProfileSchema }).safeParse(value);
+    if (!parsed.success)
+        throw new CommandFailure('failed', "Dexto didn't return your profile.", null);
+    return parsed.data.profile;
+}
+function describeProfile(profile) {
+    return [
+        `@${profile.handle} (${profile.displayName}), ${profile.visibility}`,
+        ...(profile.bio === null ? [] : [profile.bio]),
+        `${profile.links.length} links, ${profile.workEntries.length} work entries, token usage ${profile.showTokenUsage ? 'shown' : 'hidden'}`,
+    ].join('\n');
+}
+export const profileCommands = [get, update];

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

@@ -0,0 +1,5 @@
+import { type Command } from '../command.js';
+/** Chooses the project a person's sign-in acts in; `accounts` reads the same saved login. */
+export declare function projectsUse(accountsDir: string): Command;
+export declare const projectCommands: readonly Command[];
+//# sourceMappingURL=projects.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"projects.d.ts","sourceRoot":"","sources":["../../../../src/cli/cloud/commands/projects.ts"],"names":[],"mappings":"AAIA,OAAO,EAAwB,KAAK,OAAO,EAAuB,MAAM,eAAe,CAAC;AA8CxF,6FAA6F;AAC7F,wBAAgB,WAAW,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAkCxD;AAED,eAAO,MAAM,eAAe,EAAE,SAAS,OAAO,EAAmB,CAAC"}

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

@@ -0,0 +1,66 @@
+// `cloud projects`: the Cloud projects you can act in, and which one commands use.
+import { dextoAccounts } from '@dexto/agent-management';
+import { unwrap } from '@dexto/cloud-client';
+import { argument, UsageError } from '../command.js';
+async function listProjects(context) {
+    return await unwrap(await (await context.client()).GET('/v1/projects'));
+}
+const list = {
+    path: ['cloud', 'projects', 'list'],
+    summary: 'List the Cloud projects you can act in; * marks the current one.',
+    async run(context) {
+        const connection = await context.connection();
+        const projects = await listProjects(context);
+        context.output.list(projects, [
+            {
+                header: '',
+                value: (project) => project.id === connection.cloudProject ||
+                    (connection.kind === 'api_key' && projects.data.length === 1)
+                    ? '*'
+                    : '',
+            },
+            { header: 'id', value: (project) => project.id },
+            { header: 'name', value: (project) => project.name },
+            { header: 'default', value: (project) => (project.is_default ? 'yes' : '') },
+            { header: 'archived', value: (project) => project.archived_at },
+        ]);
+    },
+};
+const create = {
+    arguments: '<name>',
+    path: ['cloud', 'projects', 'create'],
+    summary: 'Create a Cloud project. Owners and Admins create projects.',
+    async run(context, input) {
+        const project = await unwrap(await (await context.client()).POST('/v1/projects', { body: { name: argument(input, 0, 'name') } }));
+        context.output.result(project, `Created Cloud project ${project.name} (${project.id}). Act in it with dexto cloud projects use ${project.id}.`);
+    },
+};
+/** Chooses the project a person's sign-in acts in; `accounts` reads the same saved login. */
+export function projectsUse(accountsDir) {
+    return {
+        arguments: '<project>',
+        path: ['cloud', 'projects', 'use'],
+        summary: 'Act in this Cloud project, by id or name, from now on. Dexto models bill it too.',
+        async run(context, input) {
+            const connection = await context.connection();
+            if (connection.kind !== 'oauth' || connection.source !== 'login')
+                throw new UsageError('A key acts only in its own project. Sign in with dexto login to choose projects.');
+            const wanted = argument(input, 0, 'project');
+            const projects = await listProjects(context);
+            const matches = projects.data.filter((project) => project.id === wanted || project.name === wanted);
+            const [project] = matches;
+            if (project === undefined)
+                throw new UsageError(`No Cloud project ${wanted}.`);
+            if (matches.length > 1)
+                throw new UsageError(`More than one project is named ${wanted}; use its id.`);
+            if (project.archived_at !== null)
+                throw new UsageError(`${project.name} is archived. Restore it in the Cloud app first.`);
+            await dextoAccounts.writeLogin(accountsDir, connection.profile, {
+                ...connection.login,
+                cloudProject: { id: project.id, name: project.name },
+            });
+            context.output.result(project, `Acting in Cloud project ${project.name} (${project.id}).`);
+        },
+    };
+}
+export const projectCommands = [list, create];

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"publish.d.ts","sourceRoot":"","sources":["../../../../src/cli/cloud/commands/publish.ts"],"names":[],"mappings":"AAUA,OAAO,EAAwD,KAAK,OAAO,EAAE,MAAM,eAAe,CAAC;AAiKnG,eAAO,MAAM,eAAe,EAAE,SAAS,OAAO,EAAc,CAAC"}