@almyty/chat 0.1.0

package/README.md

@@ -0,0 +1,42 @@
+# @almyty/chat
+
+Interactive chat REPL for almyty agents. Supports both workflow and autonomous agent modes.
+
+## Quick start
+
+```bash
+$ npx @almyty/auth login
+$ npx @almyty/chat
+$ npx @almyty/chat my-research-bot
+```
+
+## Usage
+
+Run without arguments to pick an agent from an interactive menu, or pass a name or ID to connect directly.
+
+```bash
+$ npx @almyty/chat              # interactive agent picker
+$ npx @almyty/chat <name|id>    # connect to a specific agent
+```
+
+## REPL commands
+
+| Command | Description |
+|---------|-------------|
+| `/switch <agent>` | Switch to a different agent |
+| `/agents` | List agents (current one marked) |
+| `/clear` | Clear the screen |
+| `/help` | Show available commands |
+| `/quit` | Exit the REPL |
+
+## Authentication
+
+Requires `npx @almyty/auth login` first. Reads credentials from `~/.almyty/credentials.json`. Override with `ALMYTY_TOKEN` and `ALMYTY_URL` environment variables.
+
+## Docs
+
+https://almyty.com/docs
+
+## License
+
+BSL-1.1

package/dist/client.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Tiny HTTP client used by @almyty/chat. Subset of @almyty/agents'
+ * client — kept inline so this package has zero workspace deps.
+ */
+export interface AgentInfo {
+    id: string;
+    name: string;
+    description?: string;
+    mode?: 'workflow' | 'autonomous';
+    status?: string;
+}
+export interface AgentRun {
+    id: string;
+    status: string;
+    output?: any;
+    error?: string;
+    steps?: any[];
+}
+export declare class AlmytyClient {
+    private readonly baseUrl;
+    private readonly token;
+    constructor(baseUrl: string, token: string);
+    private request;
+    listAgents(): Promise<AgentInfo[]>;
+    findAgentByNameOrId(nameOrId: string): Promise<AgentInfo | null>;
+    invokeAgent(agentId: string, input: Record<string, any>): Promise<any>;
+    startAgentRun(agentId: string, input: any): Promise<AgentRun>;
+    getRun(agentId: string, runId: string): Promise<AgentRun>;
+    sendRunInput(agentId: string, runId: string, input: string): Promise<void>;
+    pollRun(agentId: string, runId: string, options?: {
+        intervalMs?: number;
+        timeoutMs?: number;
+        onStep?: (run: AgentRun) => void;
+    }): Promise<AgentRun>;
+}

package/dist/client.js

@@ -0,0 +1,107 @@
+/**
+ * Tiny HTTP client used by @almyty/chat. Subset of @almyty/agents'
+ * client — kept inline so this package has zero workspace deps.
+ */
+const TERMINAL_STATUSES = new Set(['completed', 'failed', 'cancelled', 'timeout']);
+export class AlmytyClient {
+    baseUrl;
+    token;
+    constructor(baseUrl, token) {
+        this.baseUrl = baseUrl.replace(/\/$/, '');
+        this.token = token;
+    }
+    async request(path, init = {}) {
+        const url = `${this.baseUrl}${path}`;
+        const headers = {
+            Authorization: `Bearer ${this.token}`,
+            'Content-Type': 'application/json',
+            ...(init.headers || {}),
+        };
+        const res = await fetch(url, { ...init, headers });
+        if (!res.ok) {
+            if (res.status === 401) {
+                throw new Error('Authentication failed. Run: npx @almyty/auth login');
+            }
+            const text = await res.text().catch(() => '');
+            throw new Error(`API error ${res.status}: ${text}`);
+        }
+        if (res.status === 204)
+            return null;
+        return res.json();
+    }
+    async listAgents() {
+        const data = await this.request('/agents');
+        const agents = data?.data?.data || data?.data || data || [];
+        return agents.map((a) => ({
+            id: a.id,
+            name: a.name,
+            description: a.description,
+            mode: a.mode,
+            status: a.status,
+        }));
+    }
+    async findAgentByNameOrId(nameOrId) {
+        const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+        if (uuidRegex.test(nameOrId)) {
+            try {
+                const data = await this.request(`/agents/${nameOrId}`);
+                const a = data?.data ?? data;
+                if (a?.id) {
+                    return { id: a.id, name: a.name, description: a.description, mode: a.mode, status: a.status };
+                }
+            }
+            catch {
+                // fall through
+            }
+        }
+        const all = await this.listAgents();
+        const lower = nameOrId.toLowerCase();
+        return (all.find((a) => a.name === nameOrId) ||
+            all.find((a) => a.name.toLowerCase() === lower) ||
+            all.find((a) => a.name.toLowerCase().replace(/\s+/g, '-') === lower) ||
+            null);
+    }
+    async invokeAgent(agentId, input) {
+        const data = await this.request(`/agents/${agentId}/invoke`, {
+            method: 'POST',
+            body: JSON.stringify({ input }),
+        });
+        return data?.data ?? data;
+    }
+    async startAgentRun(agentId, input) {
+        const data = await this.request(`/agents/${agentId}/runs`, {
+            method: 'POST',
+            body: JSON.stringify({ input }),
+        });
+        const run = data?.data ?? data;
+        return { id: run.id, status: run.status };
+    }
+    async getRun(agentId, runId) {
+        const data = await this.request(`/agents/${agentId}/runs/${runId}`);
+        return (data?.data ?? data);
+    }
+    async sendRunInput(agentId, runId, input) {
+        await this.request(`/agents/${agentId}/runs/${runId}/input`, {
+            method: 'POST',
+            body: JSON.stringify({ input }),
+        });
+    }
+    async pollRun(agentId, runId, options = {}) {
+        const intervalMs = options.intervalMs ?? 1500;
+        const timeoutMs = options.timeoutMs ?? 5 * 60_000;
+        const deadline = Date.now() + timeoutMs;
+        let lastStepCount = -1;
+        while (Date.now() < deadline) {
+            const run = await this.getRun(agentId, runId);
+            if (Array.isArray(run.steps) && run.steps.length !== lastStepCount) {
+                lastStepCount = run.steps.length;
+                options.onStep?.(run);
+            }
+            if (run.status && (TERMINAL_STATUSES.has(run.status) || run.status === 'waiting_input')) {
+                return run;
+            }
+            await new Promise((r) => setTimeout(r, intervalMs));
+        }
+        throw new Error(`Run ${runId} did not finish within ${Math.round(timeoutMs / 1000)}s`);
+    }
+}

package/dist/credentials.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Read shared almyty credentials from ~/.almyty/credentials.json.
+ *
+ * Identical to the helper in @almyty/auth and @almyty/agents — kept
+ * inline to keep each CLI package self-contained.
+ */
+export declare const CREDENTIALS_FILE: string;
+export interface StoredCredentials {
+    url: string;
+    token: string;
+    email?: string;
+    frontendUrl?: string;
+}
+export declare function loadCredentials(): StoredCredentials | null;
+export declare function resolveCredentialsOrExit(): StoredCredentials;

package/dist/credentials.js

@@ -0,0 +1,33 @@
+/**
+ * Read shared almyty credentials from ~/.almyty/credentials.json.
+ *
+ * Identical to the helper in @almyty/auth and @almyty/agents — kept
+ * inline to keep each CLI package self-contained.
+ */
+import { readFileSync, existsSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+export const CREDENTIALS_FILE = join(homedir(), '.almyty', 'credentials.json');
+export function loadCredentials() {
+    try {
+        if (!existsSync(CREDENTIALS_FILE))
+            return null;
+        return JSON.parse(readFileSync(CREDENTIALS_FILE, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+export function resolveCredentialsOrExit() {
+    const envToken = process.env.ALMYTY_TOKEN;
+    const envUrl = process.env.ALMYTY_URL || 'https://api.almyty.com';
+    if (envToken)
+        return { url: envUrl, token: envToken };
+    const stored = loadCredentials();
+    if (stored?.token)
+        return stored;
+    console.error('Not authenticated. Run one of:');
+    console.error('  npx @almyty/auth login');
+    console.error('  export ALMYTY_TOKEN=<your-token>');
+    process.exit(1);
+}

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+/**
+ * @almyty/chat — interactive REPL with almyty agents.
+ *
+ *   npx @almyty/chat                       # pick from a menu
+ *   npx @almyty/chat <agent>               # start chatting with that agent
+ *
+ * Reads credentials from ~/.almyty/credentials.json (created by
+ * `npx @almyty/auth login`).
+ *
+ * Slash commands inside the REPL:
+ *
+ *   /switch <agent>   switch to a different agent
+ *   /agents           list agents in your organization
+ *   /clear            clear the screen
+ *   /help             show command list
+ *   /quit, /exit      leave the REPL
+ */
+export {};

package/dist/index.js

@@ -0,0 +1,290 @@
+#!/usr/bin/env node
+/**
+ * @almyty/chat — interactive REPL with almyty agents.
+ *
+ *   npx @almyty/chat                       # pick from a menu
+ *   npx @almyty/chat <agent>               # start chatting with that agent
+ *
+ * Reads credentials from ~/.almyty/credentials.json (created by
+ * `npx @almyty/auth login`).
+ *
+ * Slash commands inside the REPL:
+ *
+ *   /switch <agent>   switch to a different agent
+ *   /agents           list agents in your organization
+ *   /clear            clear the screen
+ *   /help             show command list
+ *   /quit, /exit      leave the REPL
+ */
+import { createInterface } from 'readline';
+import { AlmytyClient } from './client.js';
+import { resolveCredentialsOrExit } from './credentials.js';
+const VERSION = '0.1.0';
+function printHelp() {
+    console.log(`
+@almyty/chat v${VERSION}
+
+Usage:
+  npx @almyty/chat                       Pick an agent from a menu
+  npx @almyty/chat <name|id>             Start chatting with that agent
+
+Inside the REPL:
+  /switch <agent>   switch to a different agent
+  /agents           list agents in your organization
+  /clear            clear the screen
+  /help             show command list
+  /quit, /exit      leave the REPL
+
+Login:
+  npx @almyty/auth login                 Browser-based login
+`);
+}
+function printAgentBanner(agent) {
+    console.log('');
+    console.log(`  💬 ${agent.name}${agent.mode ? ` [${agent.mode}]` : ''}`);
+    if (agent.description)
+        console.log(`     ${agent.description}`);
+    console.log('');
+    console.log('  Type your message, or /help for commands. /quit to exit.');
+    console.log('');
+}
+function formatStep(step) {
+    if (!step)
+        return null;
+    switch (step.type) {
+        case 'llm_call':
+            if (step.output?.content)
+                return `  ${step.output.content}`;
+            return `  · llm_call (${step.tokens?.input ?? 0}↓ / ${step.tokens?.output ?? 0}↑)`;
+        case 'tool_call':
+            return `  · tool_call → ${step.input?.tool ?? '?'}`;
+        case 'sub_agent_call':
+            return `  · sub_agent_call → ${step.input?.agentId ?? '?'}`;
+        case 'error':
+            return `  ! error: ${step.error}`;
+        default:
+            return null;
+    }
+}
+async function pickAgent(client) {
+    const agents = await client.listAgents();
+    if (agents.length === 0) {
+        console.error('No agents in your organization. Create one at https://app.almyty.com/agents');
+        return null;
+    }
+    if (agents.length === 1) {
+        return agents[0];
+    }
+    console.log('');
+    console.log('  Pick an agent:');
+    agents.forEach((a, i) => {
+        const mode = a.mode ? ` [${a.mode}]` : '';
+        console.log(`    ${i + 1}. ${a.name}${mode}`);
+    });
+    console.log('');
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    const answer = await new Promise((resolve) => {
+        rl.question('  Enter number: ', (input) => {
+            rl.close();
+            resolve(input.trim());
+        });
+    });
+    const idx = parseInt(answer, 10) - 1;
+    if (Number.isNaN(idx) || idx < 0 || idx >= agents.length) {
+        console.error('Invalid selection.');
+        return null;
+    }
+    return agents[idx];
+}
+async function handleSlashCommand(command, state) {
+    const [cmd, ...rest] = command.slice(1).trim().split(/\s+/);
+    switch (cmd) {
+        case 'quit':
+        case 'exit':
+            return { exit: true };
+        case 'help':
+            console.log('');
+            console.log('  /switch <agent>   switch to a different agent');
+            console.log('  /agents           list agents in your organization');
+            console.log('  /clear            clear the screen');
+            console.log('  /quit, /exit      leave the REPL');
+            console.log('  /help             this help');
+            console.log('');
+            return {};
+        case 'clear':
+            process.stdout.write('\x1b[2J\x1b[H');
+            printAgentBanner(state.agent);
+            return {};
+        case 'agents': {
+            const agents = await state.client.listAgents();
+            if (agents.length === 0) {
+                console.log('  (no agents in this organization)');
+                return {};
+            }
+            console.log('');
+            for (const a of agents) {
+                const marker = a.id === state.agent.id ? '→' : ' ';
+                const mode = a.mode ? ` [${a.mode}]` : '';
+                console.log(`  ${marker} ${a.name}${mode}${a.description ? ' — ' + a.description : ''}`);
+            }
+            console.log('');
+            return {};
+        }
+        case 'switch': {
+            const target = rest.join(' ').trim();
+            if (!target) {
+                console.log('  Usage: /switch <agent name or id>');
+                return {};
+            }
+            const next = await state.client.findAgentByNameOrId(target);
+            if (!next) {
+                console.log(`  Agent "${target}" not found.`);
+                return {};
+            }
+            state.agent = next;
+            state.pendingRunId = null;
+            printAgentBanner(state.agent);
+            return {};
+        }
+        default:
+            console.log(`  Unknown command: /${cmd}. Type /help for available commands.`);
+            return {};
+    }
+}
+async function handleAutonomousTurn(state, message) {
+    let runId;
+    if (state.pendingRunId) {
+        await state.client.sendRunInput(state.agent.id, state.pendingRunId, message);
+        runId = state.pendingRunId;
+        state.pendingRunId = null;
+    }
+    else {
+        const run = await state.client.startAgentRun(state.agent.id, message);
+        runId = run.id;
+    }
+    let printed = 0;
+    const final = await state.client.pollRun(state.agent.id, runId, {
+        onStep: (run) => {
+            const newSteps = (run.steps ?? []).slice(printed);
+            for (const step of newSteps) {
+                const line = formatStep(step);
+                if (line)
+                    console.log(line);
+            }
+            printed = run.steps?.length ?? printed;
+        },
+    });
+    if (final.status === 'waiting_input') {
+        state.pendingRunId = runId;
+        console.log('');
+        console.log('  (agent is waiting for your input — answer below)');
+        console.log('');
+        return;
+    }
+    if (final.status === 'completed') {
+        if (final.output != null) {
+            console.log('');
+            console.log(typeof final.output === 'string' ? `  ${final.output}` : JSON.stringify(final.output, null, 2));
+        }
+        return;
+    }
+    console.log('');
+    console.log(`  Run ${final.status}${final.error ? `: ${final.error}` : ''}`);
+}
+async function handleWorkflowTurn(state, message) {
+    const result = await state.client.invokeAgent(state.agent.id, { message });
+    const output = result?.output ?? result?.data?.output ?? result;
+    if (output == null) {
+        console.log('  (no output)');
+        return;
+    }
+    console.log('');
+    if (typeof output === 'string') {
+        console.log(`  ${output}`);
+    }
+    else {
+        console.log(JSON.stringify(output, null, 2).split('\n').map((l) => '  ' + l).join('\n'));
+    }
+}
+async function handleUserTurn(state, message) {
+    if (state.agent.mode === 'autonomous') {
+        return handleAutonomousTurn(state, message);
+    }
+    return handleWorkflowTurn(state, message);
+}
+async function startChat(client, agent) {
+    const state = { client, agent, pendingRunId: null };
+    printAgentBanner(state.agent);
+    const rl = createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        prompt: '> ',
+    });
+    rl.prompt();
+    rl.on('line', async (raw) => {
+        const line = raw.trim();
+        if (!line) {
+            rl.prompt();
+            return;
+        }
+        if (line.startsWith('/')) {
+            try {
+                const { exit } = await handleSlashCommand(line, state);
+                if (exit) {
+                    rl.close();
+                    return;
+                }
+            }
+            catch (err) {
+                console.error(`  Error: ${err.message}`);
+            }
+            rl.prompt();
+            return;
+        }
+        try {
+            await handleUserTurn(state, line);
+        }
+        catch (err) {
+            console.error(`  Error: ${err.message}`);
+        }
+        console.log('');
+        rl.prompt();
+    });
+    rl.on('close', () => {
+        console.log('');
+        console.log('Chat ended.');
+        process.exit(0);
+    });
+}
+async function main() {
+    const argv = process.argv.slice(2);
+    if (argv.includes('--version') || argv.includes('-v')) {
+        console.log(VERSION);
+        return;
+    }
+    if (argv.includes('--help') || argv.includes('-h')) {
+        printHelp();
+        return;
+    }
+    const creds = resolveCredentialsOrExit();
+    const client = new AlmytyClient(creds.url, creds.token);
+    let agent = null;
+    const ref = argv.find((a) => !a.startsWith('-'));
+    if (ref) {
+        agent = await client.findAgentByNameOrId(ref);
+        if (!agent) {
+            console.error(`Agent not found: ${ref}`);
+            process.exit(1);
+        }
+    }
+    else {
+        agent = await pickAgent(client);
+        if (!agent)
+            process.exit(1);
+    }
+    await startChat(client, agent);
+}
+main().catch((err) => {
+    console.error(`Error: ${err.message}`);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@almyty/chat",
+  "version": "0.1.0",
+  "description": "Interactive chat REPL with almyty agents",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "almyty-chat": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/index.ts",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "almyty",
+    "agents",
+    "chat",
+    "repl",
+    "cli"
+  ],
+  "author": "almyty",
+  "license": "BSL-1.1",
+  "devDependencies": {
+    "@types/node": "^25.4.0",
+    "tsx": "^4.7.0",
+    "typescript": "^5.3.0",
+    "vitest": "^4.1.0"
+  }
+}