@argentic-ai/client 0.0.0-stage → 0.1.14

package/dist/tools.js

@@ -0,0 +1,570 @@
+// Retry-safe tools for real services: Stripe, Resend, SMTP, Slack, GitHub and a generic HTTP POST.
+// Every action Argentic hands you carries a stable key (`agent:seq`). These tools use it so a cut-off
+// action can be tried again safely: the provider's own idempotency where it has one, and for the three
+// that have none (SMTP, Slack, GitHub) a marker the tool looks for before it sends again.
+// No dependencies, Node 22+. What each provider can and cannot promise is in TOOLS.md.
+import { createHash } from 'node:crypto';
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+import * as net from 'node:net';
+import * as tls from 'node:tls';
+import { RetryLater } from "./argentic.js";
+class IntentLog {
+    path;
+    entries = {};
+    constructor(path) {
+        this.path = path;
+        try {
+            this.entries = JSON.parse(readFileSync(path, 'utf8')).entries ?? {};
+        }
+        catch {
+            this.entries = {};
+        }
+    }
+    get(key) {
+        return this.entries[key];
+    }
+    set(key, e) {
+        this.entries[key] = e;
+        mkdirSync(dirname(this.path) || '.', { recursive: true });
+        const tmp = `${this.path}.${process.pid}.tmp`;
+        writeFileSync(tmp, JSON.stringify({ entries: this.entries }, null, 2));
+        renameSync(tmp, this.path);
+    }
+}
+// ---------------------------------------------------------------------------
+// Shared pieces
+const wait = (ms) => new Promise((r) => setTimeout(r, ms));
+/** A key a provider accepts (Stripe allows 255 characters, Resend 256). */
+export function providerKey(key) {
+    return key.length <= 200 ? key : 'sha256:' + createHash('sha256').update(key).digest('hex');
+}
+class Runtime {
+    log;
+    doFetch;
+    sleep;
+    tries;
+    backoffMs;
+    constructor(o) {
+        this.log = new IntentLog(o.statePath ?? '.argentic-intents.json');
+        this.doFetch = o.fetch ?? fetch;
+        this.sleep = o.sleep ?? wait;
+        this.tries = Math.max(1, o.tries ?? 4);
+        this.backoffMs = o.backoffMs ?? [500, 1500, 4000];
+    }
+    /**
+     * Run one action once. A finished intent returns its stored result. `attempt` tells the sender
+     * whether an earlier attempt may have landed (a restart that found "started", or a retry in this process).
+     */
+    async once(ctx, tool, send) {
+        const prior = this.log.get(ctx.idempotencyKey);
+        if (prior?.state === 'done')
+            return prior.result;
+        const startedAt = prior?.at ?? new Date().toISOString();
+        if (!prior)
+            this.log.set(ctx.idempotencyKey, { state: 'started', tool, at: startedAt });
+        const result = await send({ maybeSent: prior?.state === 'started', startedAt });
+        this.log.set(ctx.idempotencyKey, { state: 'done', tool, at: startedAt, result });
+        return result;
+    }
+    /** Same request again after a network error, 429 or 5xx, then RetryLater. `fn` returns a Response or throws. */
+    async withRetry(what, fn, retryOn5xx = true) {
+        let last = '';
+        for (let attempt = 0; attempt < this.tries; attempt++) {
+            if (attempt > 0)
+                await this.sleep(this.backoffMs[Math.min(attempt - 1, this.backoffMs.length - 1)] ?? 0);
+            let res;
+            try {
+                res = await fn(attempt);
+            }
+            catch (e) {
+                last = e instanceof Error ? e.message : String(e);
+                continue;
+            }
+            if (res.status === 429 || res.status === 409 || (retryOn5xx && res.status >= 500)) {
+                last = `HTTP ${res.status}`;
+                const ra = Number(res.headers.get('retry-after'));
+                if (ra > 0)
+                    await this.sleep(Math.min(ra, 30) * 1000);
+                continue;
+            }
+            return res;
+        }
+        throw new RetryLater(`${what}: no answer after ${this.tries} tries (${last}). Run again to try the same action with the same key.`);
+    }
+}
+/**
+ * For a provider with no idempotency: a network error or 5xx may have landed, so before posting again look for
+ * the action by its marker. `lookup` returns the found item, undefined for "not there", or null for "cannot check".
+ * A 429 was not processed, so it is simply tried again.
+ */
+async function guarded(rt, what, policy, lookupFirst, post, lookup) {
+    let maybe = lookupFirst;
+    let last = '';
+    for (let attempt = 0; attempt < rt.tries; attempt++) {
+        if (attempt > 0)
+            await rt.sleep(rt.backoffMs[Math.min(attempt - 1, rt.backoffMs.length - 1)] ?? 0);
+        if (maybe) {
+            const found = await lookup();
+            if (found)
+                return { hit: found };
+            if (found === null && policy === 'hold')
+                return { unknown: true };
+        }
+        try {
+            const res = await post();
+            if (res.status === 429) {
+                const ra = Number(res.headers.get('retry-after'));
+                if (ra > 0)
+                    await rt.sleep(Math.min(ra, 30) * 1000);
+                last = 'HTTP 429';
+                continue;
+            }
+            if (res.status >= 500) {
+                maybe = true;
+                last = `HTTP ${res.status}`;
+                continue;
+            }
+            return { res };
+        }
+        catch (e) {
+            maybe = true;
+            last = e instanceof Error ? e.message : String(e);
+        }
+    }
+    throw new RetryLater(`${what}: no answer after ${rt.tries} tries (${last}). Run again: it looks for the action before sending it again.`);
+}
+const bodyOf = async (res) => {
+    const text = await res.text();
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return { raw: text.slice(0, 500) };
+    }
+};
+const str = { type: 'string' };
+const ambiguousNote = (what) => `${what} may or may not have been delivered before the process stopped, and it cannot be checked. It was not sent again. Check by hand before asking for it again.`;
+// ---------------------------------------------------------------------------
+// Stripe: native idempotency (Idempotency-Key header).
+function stripeTools(rt, o) {
+    const base = (o.baseUrl ?? 'https://api.stripe.com').replace(/\/+$/, '');
+    const call = async (ctx, path, params) => {
+        const res = await rt.withRetry('stripe', () => rt.doFetch(base + path, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${o.secretKey}`,
+                'Content-Type': 'application/x-www-form-urlencoded',
+                'Idempotency-Key': providerKey(ctx.idempotencyKey),
+            },
+            body: new URLSearchParams(params).toString(),
+        }), 
+        // Stripe stores a 500 under the key and replays it, so asking again cannot change it.
+        false);
+        const json = await bodyOf(res);
+        const replayed = res.headers.get('idempotent-replayed') === 'true';
+        if (!res.ok) {
+            return { ok: false, status: res.status, error: json?.error?.message ?? json?.error?.code ?? 'request failed', code: json?.error?.code, replayed };
+        }
+        return { ok: true, id: json.id, status: json.status, amount: json.amount, currency: json.currency, replayed };
+    };
+    const capped = (amount) => {
+        if (!Number.isInteger(amount) || amount <= 0)
+            return 'amount must be a positive whole number of minor units (cents)';
+        if (o.maxAmount !== undefined && amount > o.maxAmount)
+            return `amount is over the limit of ${o.maxAmount}`;
+        return undefined;
+    };
+    return [
+        {
+            name: 'stripe_refund',
+            description: 'Refund a Stripe payment. Give the payment_intent id (pi_...) and, for a partial refund, the amount in cents.',
+            parameters: {
+                type: 'object',
+                properties: { payment_intent: str, amount: { type: 'integer', description: 'cents; omit to refund the whole payment' }, reason: { type: 'string', enum: ['duplicate', 'fraudulent', 'requested_by_customer'] } },
+                required: ['payment_intent'],
+            },
+            execute: (args, ctx) => rt.once(ctx, 'stripe_refund', async () => {
+                if (args.amount !== undefined) {
+                    const bad = capped(args.amount);
+                    if (bad)
+                        return { ok: false, error: bad };
+                }
+                else if (o.maxAmount !== undefined) {
+                    return { ok: false, error: 'a full refund needs an amount while a limit is set' };
+                }
+                const p = { payment_intent: String(args.payment_intent) };
+                if (args.amount !== undefined)
+                    p.amount = String(args.amount);
+                if (args.reason)
+                    p.reason = String(args.reason);
+                return call(ctx, '/v1/refunds', p);
+            }),
+        },
+        {
+            name: 'stripe_charge',
+            description: 'Charge a saved Stripe customer off-session. Give the customer id (cus_...), a payment_method id (pm_...), the amount in cents and a 3-letter currency.',
+            parameters: {
+                type: 'object',
+                properties: { customer: str, payment_method: str, amount: { type: 'integer' }, currency: str, description: str },
+                required: ['customer', 'payment_method', 'amount', 'currency'],
+            },
+            execute: (args, ctx) => rt.once(ctx, 'stripe_charge', async () => {
+                const bad = capped(args.amount);
+                if (bad)
+                    return { ok: false, error: bad };
+                const p = {
+                    customer: String(args.customer),
+                    payment_method: String(args.payment_method),
+                    amount: String(args.amount),
+                    currency: String(args.currency).toLowerCase(),
+                    confirm: 'true',
+                    off_session: 'true',
+                };
+                if (args.description)
+                    p.description = String(args.description);
+                return call(ctx, '/v1/payment_intents', p);
+            }),
+        },
+    ];
+}
+// ---------------------------------------------------------------------------
+// Resend: native idempotency (Idempotency-Key header).
+function resendTools(rt, o, name) {
+    const base = (o.baseUrl ?? 'https://api.resend.com').replace(/\/+$/, '');
+    return [
+        {
+            name,
+            description: 'Send an email. Plain text in body; add html for a formatted version.',
+            parameters: { type: 'object', properties: { to: str, subject: str, body: str, html: str, reply_to: str }, required: ['to', 'subject', 'body'] },
+            execute: (args, ctx) => rt.once(ctx, name, async () => {
+                const payload = { from: o.from, to: [String(args.to)], subject: String(args.subject), text: String(args.body) };
+                if (args.html)
+                    payload.html = String(args.html);
+                if (args.reply_to)
+                    payload.reply_to = String(args.reply_to);
+                const res = await rt.withRetry('resend', () => rt.doFetch(base + '/emails', {
+                    method: 'POST',
+                    headers: { Authorization: `Bearer ${o.apiKey}`, 'Content-Type': 'application/json', 'Idempotency-Key': providerKey(ctx.idempotencyKey) },
+                    body: JSON.stringify(payload),
+                }));
+                const json = await bodyOf(res);
+                if (!res.ok)
+                    return { ok: false, status: res.status, error: json?.message ?? json?.name ?? 'request failed' };
+                return { ok: true, id: json.id, to: args.to };
+            }),
+        },
+    ];
+}
+// ---------------------------------------------------------------------------
+// SMTP: no idempotency exists. A deterministic Message-ID, an intent written first, and a hold on the ambiguous case.
+class SmtpError extends Error {
+    code;
+    handedOver;
+    constructor(message, code, handedOver) {
+        super(message);
+        this.code = code;
+        this.handedOver = handedOver;
+    }
+}
+const crlf = (s) => s.replace(/\r?\n/g, '\r\n');
+const header = (s) => s.replace(/[\r\n]+/g, ' ');
+async function smtpSend(o, msg) {
+    const port = o.port ?? (o.secure ? 465 : 587);
+    let sock = o.secure
+        ? tls.connect({ host: o.host, port, rejectUnauthorized: !o.insecureTls })
+        : net.connect({ host: o.host, port });
+    sock.setTimeout(30_000);
+    let buf = '';
+    let handedOver = false;
+    const waiters = [];
+    let failure;
+    const onData = (d) => {
+        buf += d.toString('utf8');
+        for (;;) {
+            const m = buf.match(/^(?:\d{3}-[^\n]*\n)*\d{3} [^\n]*\n/);
+            if (!m)
+                return;
+            buf = buf.slice(m[0].length);
+            waiters.shift()?.(m[0]);
+        }
+    };
+    const fail = (e) => {
+        failure = failure ?? e;
+        while (waiters.length)
+            waiters.shift()('');
+    };
+    const attach = (s) => {
+        s.on('data', onData);
+        s.on('error', fail);
+        s.on('timeout', () => fail(new Error('smtp timeout')));
+        s.on('close', () => fail(new Error('smtp connection closed')));
+    };
+    attach(sock);
+    const reply = () => new Promise((resolve, reject) => {
+        if (failure)
+            return reject(failure);
+        waiters.push((line) => (failure && !line ? reject(failure) : resolve(line)));
+    });
+    const expect = async (ok) => {
+        const r = await reply();
+        const code = Number(r.slice(0, 3));
+        if (!ok.includes(code))
+            throw new SmtpError(`smtp ${r.trim().slice(0, 200)}`, code, handedOver);
+        return r;
+    };
+    const cmd = async (line, ok) => {
+        sock.write(line + '\r\n');
+        return expect(ok);
+    };
+    try {
+        await expect([220]);
+        let ehlo = await cmd(`EHLO argentic.local`, [250]);
+        if (!o.secure && /STARTTLS/i.test(ehlo)) {
+            await cmd('STARTTLS', [220]);
+            sock.removeAllListeners('data');
+            const upgraded = tls.connect({ socket: sock, host: o.host, rejectUnauthorized: !o.insecureTls });
+            sock = upgraded;
+            attach(upgraded);
+            buf = '';
+            ehlo = await cmd(`EHLO argentic.local`, [250]);
+        }
+        if (o.user) {
+            const token = Buffer.from(`\0${o.user}\0${o.pass ?? ''}`).toString('base64');
+            await cmd(`AUTH PLAIN ${token}`, [235]);
+        }
+        const from = o.from.match(/<([^>]+)>/)?.[1] ?? o.from;
+        await cmd(`MAIL FROM:<${header(from)}>`, [250]);
+        await cmd(`RCPT TO:<${header(msg.to)}>`, [250, 251]);
+        await cmd('DATA', [354]);
+        const text = [
+            `From: ${header(o.from)}`,
+            `To: ${header(msg.to)}`,
+            `Subject: ${header(msg.subject)}`,
+            `Message-ID: ${msg.messageId}`,
+            `X-Argentic-Idempotency-Key: ${header(msg.key)}`,
+            `Date: ${new Date().toUTCString()}`,
+            'MIME-Version: 1.0',
+            'Content-Type: text/plain; charset=utf-8',
+            '',
+            crlf(msg.body).replace(/^\./gm, '..'),
+        ].join('\r\n');
+        // From here on a cut-off connection leaves it unknown whether the server queued the message.
+        handedOver = true;
+        sock.write(text + '\r\n.\r\n');
+        await expect([250]);
+        handedOver = false;
+        sock.write('QUIT\r\n');
+    }
+    catch (e) {
+        if (e instanceof SmtpError)
+            throw e;
+        throw new SmtpError(e instanceof Error ? e.message : String(e), undefined, handedOver);
+    }
+    finally {
+        sock.destroy();
+    }
+}
+function smtpTools(rt, o, name) {
+    const policy = o.onAmbiguous ?? 'hold';
+    const domain = (o.from.match(/@([^>\s]+)/)?.[1] ?? 'argentic.local').replace(/[^A-Za-z0-9.-]/g, '');
+    return [
+        {
+            name,
+            description: 'Send a plain-text email.',
+            parameters: { type: 'object', properties: { to: str, subject: str, body: str }, required: ['to', 'subject', 'body'] },
+            execute: (args, ctx) => rt.once(ctx, name, async ({ maybeSent }) => {
+                if (maybeSent && policy === 'hold') {
+                    return { ok: false, outcome: 'unknown', note: ambiguousNote('This email') };
+                }
+                const messageId = `<${createHash('sha256').update(ctx.idempotencyKey).digest('hex').slice(0, 32)}@${domain}>`;
+                for (let attempt = 0; attempt < rt.tries; attempt++) {
+                    if (attempt > 0)
+                        await rt.sleep(rt.backoffMs[Math.min(attempt - 1, rt.backoffMs.length - 1)] ?? 0);
+                    try {
+                        await smtpSend(o, { to: String(args.to), subject: String(args.subject), body: String(args.body), messageId, key: ctx.idempotencyKey });
+                        return { ok: true, to: args.to, messageId };
+                    }
+                    catch (e) {
+                        const err = e;
+                        if (err.code !== undefined && err.code >= 500)
+                            return { ok: false, error: err.message };
+                        if (err.handedOver) {
+                            // The server may have queued it. Same Message-ID lets a receiver spot a copy, but nothing guarantees it.
+                            if (policy === 'hold')
+                                return { ok: false, outcome: 'unknown', note: ambiguousNote('This email') };
+                        }
+                    }
+                }
+                throw new RetryLater('smtp: could not reach the server. Run again to try the same email.');
+            }),
+        },
+    ];
+}
+// ---------------------------------------------------------------------------
+// Slack: no idempotency. The key rides in message metadata; before any repeat the tool looks for it.
+function slackTools(rt, o) {
+    const base = (o.baseUrl ?? 'https://slack.com/api').replace(/\/+$/, '');
+    const policy = o.onAmbiguous ?? 'hold';
+    const call = (method, payload) => rt.doFetch(`${base}/${method}`, {
+        method: 'POST',
+        headers: { Authorization: `Bearer ${o.token}`, 'Content-Type': 'application/json; charset=utf-8' },
+        body: JSON.stringify(payload),
+    });
+    return [
+        {
+            name: 'slack_post_message',
+            description: 'Post a message to a Slack channel (channel id, such as C0123ABCD). thread_ts replies in a thread.',
+            parameters: { type: 'object', properties: { channel: str, text: str, thread_ts: str }, required: ['channel', 'text'] },
+            execute: (args, ctx) => rt.once(ctx, 'slack_post_message', async ({ maybeSent, startedAt }) => {
+                const channel = String(args.channel);
+                if (o.channels && !o.channels.includes(channel))
+                    return { ok: false, error: `channel ${channel} is not allowed` };
+                const threadTs = args.thread_ts ? String(args.thread_ts) : undefined;
+                const lookup = async () => {
+                    const oldest = String(Math.floor(Date.parse(startedAt) / 1000) - 60);
+                    try {
+                        const res = await call(threadTs ? 'conversations.replies' : 'conversations.history', { channel, ...(threadTs ? { ts: threadTs } : {}), oldest, limit: 100, include_all_metadata: true });
+                        const r = await bodyOf(res);
+                        if (!r?.ok)
+                            return null;
+                        return (r.messages ?? []).find((m) => m?.metadata?.event_payload?.key === ctx.idempotencyKey);
+                    }
+                    catch {
+                        return null;
+                    }
+                };
+                const post = () => call('chat.postMessage', {
+                    channel,
+                    text: String(args.text),
+                    ...(threadTs ? { thread_ts: threadTs } : {}),
+                    metadata: { event_type: 'argentic_action', event_payload: { key: ctx.idempotencyKey } },
+                });
+                const out = await guarded(rt, 'slack', policy, maybeSent, post, lookup);
+                if ('unknown' in out)
+                    return { ok: false, outcome: 'unknown', note: ambiguousNote('This Slack message') };
+                if ('hit' in out)
+                    return { ok: true, ts: out.hit.ts, channel, found: true };
+                const r = await bodyOf(out.res);
+                if (!r?.ok)
+                    return { ok: false, error: r?.error ?? `HTTP ${out.res.status}` };
+                return { ok: true, ts: r.ts, channel };
+            }),
+        },
+    ];
+}
+// ---------------------------------------------------------------------------
+// GitHub: no idempotency. A hidden marker in the body; before any repeat the tool lists and looks for it.
+const marker = (key) => `<!-- argentic-key:${key.replace(/--/g, '-')} -->`;
+function githubTools(rt, o) {
+    const base = (o.baseUrl ?? 'https://api.github.com').replace(/\/+$/, '');
+    const policy = o.onAmbiguous ?? 'hold';
+    const h = { Authorization: `Bearer ${o.token}`, Accept: 'application/vnd.github+json', 'X-GitHub-Api-Version': '2022-11-28', 'Content-Type': 'application/json' };
+    const repoOk = (repo) => /^[\w.-]+\/[\w.-]+$/.test(repo) && (!o.repos || o.repos.includes(repo));
+    /** Scan newest-first pages of a list for the marker. Lists are read straight from the database, unlike search. */
+    const scan = async (url, mk) => {
+        try {
+            for (let page = 1; page <= 3; page++) {
+                const res = await rt.doFetch(`${url}${url.includes('?') ? '&' : '?'}per_page=100&page=${page}`, { headers: h });
+                if (!res.ok)
+                    return null;
+                const items = (await res.json());
+                const hit = items.find((i) => typeof i.body === 'string' && i.body.includes(mk) && !i.pull_request);
+                if (hit)
+                    return hit;
+                if (items.length < 100)
+                    return undefined;
+            }
+            return undefined;
+        }
+        catch {
+            return null;
+        }
+    };
+    const run = (name, listUrl, createUrl, makePayload) => (args, ctx) => rt.once(ctx, name, async ({ maybeSent, startedAt }) => {
+        const repo = String(args.repo);
+        if (!repoOk(repo))
+            return { ok: false, error: `repo ${repo} is not allowed` };
+        const mk = marker(ctx.idempotencyKey);
+        const since = new Date(Date.parse(startedAt) - 60_000).toISOString();
+        const out = await guarded(rt, 'github', policy, maybeSent, () => rt.doFetch(createUrl(args), { method: 'POST', headers: h, body: JSON.stringify(makePayload(args, mk)) }), () => scan(listUrl(args, since), mk));
+        if ('unknown' in out)
+            return { ok: false, outcome: 'unknown', note: ambiguousNote('This GitHub write') };
+        if ('hit' in out)
+            return { ok: true, number: out.hit.number, id: out.hit.id, url: out.hit.html_url, found: true };
+        const json = await bodyOf(out.res);
+        if (!out.res.ok)
+            return { ok: false, status: out.res.status, error: json?.message ?? 'request failed' };
+        return { ok: true, number: json.number, id: json.id, url: json.html_url };
+    });
+    return [
+        {
+            name: 'github_create_issue',
+            description: 'Open a GitHub issue. repo is owner/name.',
+            parameters: { type: 'object', properties: { repo: str, title: str, body: str, labels: { type: 'array', items: { type: 'string' } } }, required: ['repo', 'title'] },
+            execute: run('github_create_issue', (a, since) => `${base}/repos/${a.repo}/issues?state=all&sort=created&direction=desc&since=${encodeURIComponent(since)}`, (a) => `${base}/repos/${a.repo}/issues`, (a, mk) => ({ title: String(a.title), body: `${a.body ?? ''}\n\n${mk}`, ...(Array.isArray(a.labels) ? { labels: a.labels } : {}) })),
+        },
+        {
+            name: 'github_create_comment',
+            description: 'Comment on a GitHub issue or pull request. repo is owner/name.',
+            parameters: { type: 'object', properties: { repo: str, issue_number: { type: 'integer' }, body: str }, required: ['repo', 'issue_number', 'body'] },
+            execute: run('github_create_comment', (a, since) => `${base}/repos/${a.repo}/issues/${Number(a.issue_number)}/comments?since=${encodeURIComponent(since)}`, (a) => `${base}/repos/${a.repo}/issues/${Number(a.issue_number)}/comments`, (a, mk) => ({ body: `${a.body}\n\n${mk}` })),
+        },
+    ];
+}
+// ---------------------------------------------------------------------------
+// Generic HTTP POST with an Idempotency-Key header.
+function httpTools(rt, o) {
+    const hosts = new Set(o.allowHosts.map((h) => h.toLowerCase()));
+    return [
+        {
+            name: 'http_post',
+            description: 'POST a body to an allowed URL. The receiver is sent an Idempotency-Key for this action.',
+            parameters: { type: 'object', properties: { url: str, body: { type: 'string', description: 'the request body, such as JSON text' }, content_type: str }, required: ['url', 'body'] },
+            execute: (args, ctx) => rt.once(ctx, 'http_post', async () => {
+                let u;
+                try {
+                    u = new URL(String(args.url));
+                }
+                catch {
+                    return { ok: false, error: 'not a URL' };
+                }
+                if (u.protocol !== 'https:' && !(o.allowHttp && u.protocol === 'http:'))
+                    return { ok: false, error: 'only https URLs are allowed' };
+                if (!hosts.has(u.host.toLowerCase()) && !hosts.has(u.hostname.toLowerCase()))
+                    return { ok: false, error: `host ${u.host} is not allowed` };
+                const res = await rt.withRetry('http_post', () => rt.doFetch(u, {
+                    method: 'POST',
+                    redirect: 'error',
+                    headers: { ...(o.headers ?? {}), 'Content-Type': String(args.content_type ?? 'application/json'), 'Idempotency-Key': providerKey(ctx.idempotencyKey) },
+                    body: String(args.body),
+                }));
+                const text = await res.text();
+                return { ok: res.ok, status: res.status, body: text.slice(0, 2000), replayed: res.headers.get('idempotent-replayed') === 'true' || res.headers.get('idempotency-replayed') === 'true' };
+            }),
+        },
+    ];
+}
+// ---------------------------------------------------------------------------
+/**
+ * Tools for runDurable. Pass only the services you use; each tool is built from your options and your
+ * secrets, never from anything the model sends. With Resend and SMTP both set, Resend is `send_email`
+ * and SMTP is `send_email_smtp`.
+ */
+export function toolPack(opts) {
+    const rt = new Runtime(opts);
+    const out = [];
+    if (opts.stripe)
+        out.push(...stripeTools(rt, opts.stripe));
+    if (opts.resend)
+        out.push(...resendTools(rt, opts.resend, 'send_email'));
+    if (opts.smtp)
+        out.push(...smtpTools(rt, opts.smtp, opts.resend ? 'send_email_smtp' : 'send_email'));
+    if (opts.slack)
+        out.push(...slackTools(rt, opts.slack));
+    if (opts.github)
+        out.push(...githubTools(rt, opts.github));
+    if (opts.http)
+        out.push(...httpTools(rt, opts.http));
+    return out;
+}

package/package.json

@@ -1,6 +1,42 @@
 {
   "name": "@argentic-ai/client",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.14",
+  "description": "Argentic client for TypeScript. The engine runs your agent for hours, rebuilding each prompt from a journal (state blocks plus a recent tail of about 40K tokens) instead of an ever-growing transcript. Adapters for the Vercel AI SDK and Mastra.",
+  "license": "MIT",
+  "type": "module",
+  "engines": { "node": ">=22" },
+  "files": ["dist", "README.md", "LICENSE"],
+  "main": "./dist/argentic.js",
+  "bin": { "argentic": "./dist/cli.js" },
+  "types": "./dist/argentic.d.ts",
+  "exports": {
+    ".": { "types": "./dist/argentic.d.ts", "default": "./dist/argentic.js" },
+    "./ai-sdk": { "types": "./dist/ai-sdk.d.ts", "default": "./dist/ai-sdk.js" },
+    "./mastra": { "types": "./dist/mastra.d.ts", "default": "./dist/mastra.js" },
+    "./tools": { "types": "./dist/tools.d.ts", "default": "./dist/tools.js" }
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc -p tsconfig.build.json",
+    "test": "node --experimental-transform-types --disable-warning=ExperimentalWarning --test test/*.test.ts",
+    "prepack": "npm run build"
+  },
+  "peerDependencies": {
+    "ai": ">=5 <8"
+  },
+  "peerDependenciesMeta": {
+    "ai": { "optional": true }
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "ai": "^6.0.0",
+    "typescript": "^5.7.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Argentic-AI/argentic-plugins.git",
+    "directory": "adapters/typescript"
+  },
+  "homepage": "https://getargentic.com/docs",
+  "keywords": ["agents", "long-running", "context", "journal", "ai-sdk", "mastra", "argentic"],
+  "publishConfig": { "access": "public", "provenance": true }
+}