@almyty/client 0.1.0

package/dist/client.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Shared HTTP client for the almyty REST API.
+ *
+ * Used by @almyty/agents, @almyty/chat, @almyty/acp-server,
+ * and @almyty/mcp-server. Covers agent discovery, invocation,
+ * autonomous run management, and polling.
+ */
+export interface AgentInfo {
+    id: string;
+    name: string;
+    slug?: string;
+    description?: string;
+    mode?: 'workflow' | 'autonomous';
+    status?: string;
+    pipeline?: {
+        nodes?: PipelineNode[];
+    };
+    modelConfig?: Record<string, unknown>;
+}
+export interface PipelineNode {
+    id: string;
+    type: string;
+    label?: string;
+    config?: Record<string, unknown>;
+}
+export interface AgentRun {
+    id: string;
+    agentId?: string;
+    status: string;
+    conversationId?: string;
+    output?: unknown;
+    error?: string;
+    steps?: unknown[];
+    totalCost?: number;
+    totalTokens?: number;
+}
+export interface RunLimits {
+    maxSteps?: number;
+    maxCostCents?: number;
+    maxDurationMs?: number;
+}
+export declare class AlmytyClient {
+    private readonly baseUrl;
+    private readonly token;
+    constructor(baseUrl: string, token: string);
+    private headers;
+    request(path: string, init?: RequestInit): Promise<any>;
+    private unwrap;
+    listAgents(): Promise<AgentInfo[]>;
+    getAgent(id: string): Promise<AgentInfo>;
+    findAgentByNameOrId(nameOrId: string): Promise<AgentInfo | null>;
+    invokeAgent(agentId: string, input: Record<string, any>): Promise<any>;
+    startRun(agentId: string, input: any, options?: RunLimits & {
+        conversationId?: string;
+    }): Promise<AgentRun>;
+    getRun(agentId: string, runId: string): Promise<AgentRun>;
+    listRuns(agentId: string, page?: number, limit?: number): Promise<{
+        data: AgentRun[];
+        total: number;
+    }>;
+    sendRunInput(agentId: string, runId: string, input: string): Promise<void>;
+    cancelRun(agentId: string, runId: string): Promise<void>;
+    /**
+     * Poll a run until it reaches a terminal status (or waiting_input).
+     */
+    pollRun(agentId: string, runId: string, options?: {
+        intervalMs?: number;
+        timeoutMs?: number;
+        onStep?: (run: AgentRun) => void;
+    }): Promise<AgentRun>;
+}

package/dist/client.js

@@ -0,0 +1,158 @@
+/**
+ * Shared HTTP client for the almyty REST API.
+ *
+ * Used by @almyty/agents, @almyty/chat, @almyty/acp-server,
+ * and @almyty/mcp-server. Covers agent discovery, invocation,
+ * autonomous run management, and polling.
+ */
+const TERMINAL_STATUSES = new Set(['completed', 'failed', 'cancelled', 'timeout']);
+export class AlmytyClient {
+    baseUrl;
+    token;
+    constructor(baseUrl, token) {
+        this.baseUrl = baseUrl.replace(/\/$/, '');
+        this.token = token;
+    }
+    // ── HTTP helpers ────────────────────────────────────────────────
+    headers() {
+        return {
+            Authorization: `Bearer ${this.token}`,
+            'Content-Type': 'application/json',
+        };
+    }
+    async request(path, init = {}) {
+        const url = `${this.baseUrl}${path}`;
+        const headers = {
+            ...this.headers(),
+            ...(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();
+    }
+    unwrap(data) {
+        return data?.data ?? data;
+    }
+    // ── Agent discovery ─────────────────────────────────────────────
+    async listAgents() {
+        const data = await this.request('/agents');
+        const list = data?.data?.data || data?.data || data || [];
+        return list.map((a) => ({
+            id: a.id,
+            name: a.name,
+            slug: a.slug,
+            description: a.description,
+            mode: a.mode,
+            status: a.status,
+            pipeline: a.pipeline,
+            modelConfig: a.modelConfig,
+        }));
+    }
+    async getAgent(id) {
+        const data = await this.request(`/agents/${encodeURIComponent(id)}`);
+        return this.unwrap(data);
+    }
+    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 agent = await this.getAgent(nameOrId);
+                if (agent?.id)
+                    return agent;
+            }
+            catch {
+                // fall through to name search
+            }
+        }
+        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) ||
+            all.find((a) => a.slug === nameOrId) ||
+            all.find((a) => a.slug?.toLowerCase() === lower) ||
+            null);
+    }
+    // ── Workflow invocation ───────────────────────���─────────────────
+    async invokeAgent(agentId, input) {
+        const data = await this.request(`/agents/${encodeURIComponent(agentId)}/invoke`, {
+            method: 'POST',
+            body: JSON.stringify({ input }),
+        });
+        return this.unwrap(data);
+    }
+    // ── Autonomous run management ───────────────────────────────────
+    async startRun(agentId, input, options) {
+        const body = { input };
+        if (options?.maxSteps)
+            body.maxSteps = options.maxSteps;
+        if (options?.maxCostCents)
+            body.maxCostCents = options.maxCostCents;
+        if (options?.maxDurationMs)
+            body.maxDurationMs = options.maxDurationMs;
+        if (options?.conversationId)
+            body.conversationId = options.conversationId;
+        const data = await this.request(`/agents/${encodeURIComponent(agentId)}/runs`, {
+            method: 'POST',
+            body: JSON.stringify(body),
+        });
+        const run = this.unwrap(data);
+        return {
+            id: run.id,
+            agentId: run.agentId,
+            status: run.status,
+            conversationId: run.conversationId,
+            output: run.output,
+            error: run.error,
+            steps: run.steps,
+            totalCost: run.totalCost,
+            totalTokens: run.totalTokens,
+        };
+    }
+    async getRun(agentId, runId) {
+        const data = await this.request(`/agents/${encodeURIComponent(agentId)}/runs/${encodeURIComponent(runId)}`);
+        return this.unwrap(data);
+    }
+    async listRuns(agentId, page = 1, limit = 20) {
+        const data = await this.request(`/agents/${encodeURIComponent(agentId)}/runs?page=${page}&limit=${limit}`);
+        return {
+            data: data?.data ?? [],
+            total: data?.pagination?.total ?? 0,
+        };
+    }
+    async sendRunInput(agentId, runId, input) {
+        await this.request(`/agents/${encodeURIComponent(agentId)}/runs/${encodeURIComponent(runId)}/input`, { method: 'POST', body: JSON.stringify({ input }) });
+    }
+    async cancelRun(agentId, runId) {
+        await this.request(`/agents/${encodeURIComponent(agentId)}/runs/${encodeURIComponent(runId)}/cancel`, { method: 'POST' });
+    }
+    /**
+     * Poll a run until it reaches a terminal status (or waiting_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,22 @@
+/**
+ * Shared credential resolver for all almyty CLI packages.
+ *
+ * Reads from ALMYTY_TOKEN env var first, then falls back to
+ * ~/.almyty/credentials.json written by `npx @almyty/auth login`.
+ */
+export declare const CREDENTIALS_FILE: string;
+export interface StoredCredentials {
+    url: string;
+    token: string;
+    email?: string;
+    frontendUrl?: string;
+}
+export declare function loadCredentials(): StoredCredentials | null;
+/**
+ * Resolve credentials from env or file. Returns null if nothing found.
+ */
+export declare function resolveCredentials(): StoredCredentials | null;
+/**
+ * Resolve credentials or exit with an error message.
+ */
+export declare function resolveCredentialsOrExit(): StoredCredentials;

package/dist/credentials.js

@@ -0,0 +1,45 @@
+/**
+ * Shared credential resolver for all almyty CLI packages.
+ *
+ * Reads from ALMYTY_TOKEN env var first, then falls back to
+ * ~/.almyty/credentials.json written by `npx @almyty/auth login`.
+ */
+import { readFileSync, existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node: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;
+    }
+}
+/**
+ * Resolve credentials from env or file. Returns null if nothing found.
+ */
+export function resolveCredentials() {
+    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;
+    return null;
+}
+/**
+ * Resolve credentials or exit with an error message.
+ */
+export function resolveCredentialsOrExit() {
+    const creds = resolveCredentials();
+    if (creds)
+        return creds;
+    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,4 @@
+export { AlmytyClient } from './client.js';
+export type { AgentInfo, AgentRun, PipelineNode, RunLimits } from './client.js';
+export { loadCredentials, resolveCredentials, resolveCredentialsOrExit, CREDENTIALS_FILE, } from './credentials.js';
+export type { StoredCredentials } from './credentials.js';

package/dist/index.js

@@ -0,0 +1,2 @@
+export { AlmytyClient } from './client.js';
+export { loadCredentials, resolveCredentials, resolveCredentialsOrExit, CREDENTIALS_FILE, } from './credentials.js';

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@almyty/client",
+  "version": "0.1.0",
+  "description": "Shared HTTP client and credential resolver for almyty CLI packages",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "almyty",
+    "client",
+    "sdk"
+  ],
+  "author": "almyty",
+  "license": "BSL-1.1",
+  "devDependencies": {
+    "@types/node": "^25.4.0",
+    "typescript": "^5.3.0",
+    "vitest": "^4.1.0"
+  }
+}