akribes 0.21.17

package/CHANGELOG.md

@@ -0,0 +1,30 @@
+# Changelog
+
+All notable changes to `akribes` (TypeScript SDK) will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and the package follows [Semantic Versioning](https://semver.org/).
+
+## [0.21.16] — 2026-05-30
+
+First public release of the TypeScript SDK.
+
+### Added
+- Pure-ESM `AkribesClient`, browser-safe (only the global `fetch` and
+  `EventSource`).
+- Resource sub-clients: `projects`, `scripts`, `versions`, `executions`,
+  `events`, `documents`, `tokens`, `evals`, `mcp`, `drafts`, `clients`.
+- Typed streaming via `createRunStream` with discriminated-union events
+  and a `subscribe-before-POST` flow that avoids missed events on the
+  start edge.
+- Document ingest with hash-deduped server-side storage.
+- Long-lived event subscription with heartbeat and `onHeartbeatStatus`
+  callback for browser re-auth.
+- Typed errors (`AkribesError`, `AkribesAuthError`, `AkribesNotFoundError`,
+  `AkribesRateLimitError`, `AkribesTransientError`, `AkribesScriptError`,
+  `AkribesTimeoutError`).
+- Full `.d.ts` types ship; the package is `"type": "module"` only.
+
+### Server compatibility
+
+Targets akribes-server v0.21.16. Accepts both the new `akribes_tk_…`
+scoped-token prefix and the legacy `aura_tk_…` prefix.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Podesta
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,160 @@
+# akribes
+
+TypeScript / Bun client SDK for the [Akribes](https://akribes.ai) workflow server.
+
+Akribes is a domain-specific language and execution platform for AI workflows — multi-agent, multi-step processes with type-checked inputs, structured outputs, and a real-time event stream. This package is the typed client; you author `.akr` workflows and the server runs them.
+
+Browser-safe: zero Node-only deps, only the global `fetch` and `EventSource`.
+
+## Install
+
+```bash
+npm install akribes
+# or
+bun add akribes
+```
+
+## Quickstart
+
+```ts
+import { AkribesClient } from "akribes";
+
+const client = new AkribesClient({
+  baseUrl: "https://akribes.example.com",
+  projectId: 2,
+  token: process.env.AKRIBES_SERVICE_TOKEN!,
+});
+
+// List projects
+const projects = await client.projects.list();
+for (const p of projects) console.log(`${p.id}: ${p.name}`);
+
+// Run a workflow and await the result
+const { execution_id } = await client.executions.run("my_script");
+const result = await client.executions.awaitExecution(execution_id);
+console.log(result);
+```
+
+## Authentication
+
+`AkribesClient` accepts either a **service token** (long-lived, from
+`AKRIBES_SERVICE_TOKEN_<NAME>=<scope>:<secret>`) or a **scoped token**
+(`akribes_tk_...` — legacy `aura_tk_...` still accepted — minted via
+`client.tokens.mint(...)`).
+
+- **Backend / CLI**: pass the service-token secret directly.
+- **Browser**: never ship a service token. Mint a short-lived scoped
+  token server-side and hand it to the browser:
+
+```ts
+// Server side, with a service token.
+const minted = await backendClient.tokens.mint({
+  user_email: "alice@acme.com",
+  scopes: { projects: 2, role: "editor" },
+  expires_in: 8 * 3600,
+  label: "web-session",
+});
+// `minted.token` is the `akribes_tk_…` string to ship to the browser.
+
+// Browser side.
+const client = new AkribesClient({
+  baseUrl: "https://akribes.example.com",
+  projectId: 2,
+  token: mintedTokenFromBackend,
+  onHeartbeatStatus: (status) => {
+    // Prompt for re-auth when the token is revoked / expires.
+    if (status === "auth_failed") promptRelogin();
+  },
+});
+```
+
+See the [auth docs](https://akribes.ai/docs/authentication) for the full two-tier token model.
+
+### Prefer `Authorization: Bearer` over `?token=…` (#789)
+
+The SDK ships the bearer token in the `Authorization` header on every
+HTTP call and on its WebSocket upgrade — the recommended path for any
+non-browser caller. The `?token=…` query-string fallback exists only
+because browser `EventSource` / `WebSocket` constructors cannot set
+arbitrary headers; treat it as a browser-only escape hatch.
+
+Reasons to avoid query-string tokens for CLIs, backends, and scripts:
+
+- Reverse proxies (nginx, Ingress, CDN) log the full URL, including
+  the token, in access logs by default.
+- Browsers leak `?token=` in the `Referer` header on cross-origin
+  sub-resource requests originating from the same page.
+- CI runners (Forgejo / GitHub Actions) echo `curl` command-lines into
+  job logs.
+- HTTP error responses and OTel spans sometimes capture `url.full`.
+
+The server stamps `X-Token-Source: query-param` on responses to any
+request that used the query fallback, so operators can chart adoption
+away from the query form without having to log the token.
+
+## Streaming execution
+
+`runStream` yields typed events as the workflow executes:
+
+```ts
+import { createRunStream } from "akribes";
+
+const run = await createRunStream({
+  scriptName: "summarize",
+  inputs: { brief: "Distill the attached doc into 3 bullets." },
+  starter: client.executions,
+  events: client.events,
+});
+
+run.on.output((chunk) => process.stdout.write(chunk.chunk));
+run.on.error((e) => console.error("Workflow failed:", e.message));
+
+const result = await run.output();
+console.log("Final result:", result);
+```
+
+## Document ingest
+
+Upload a document and run a workflow against it without re-uploading on
+each retry — `documents.ingest` is hash-deduped server-side:
+
+```ts
+import { readFile } from "node:fs/promises";
+
+const data = await readFile("./contract.pdf");
+const { documentId } = await client.documents.ingest("contract.pdf", data);
+
+const { execution_id } = await client.executions.run("extract_clauses", {
+  inputs: { doc: documentId },
+});
+```
+
+## Browser usage
+
+Scoped tokens only — never expose a service token client-side. Rotate
+via `setToken()` after re-auth, and call `clients.resumeHeartbeat()` if
+you wired `onHeartbeatStatus` and paused on `auth_failed`:
+
+```ts
+client.setToken(newToken);
+client.clients.resumeHeartbeat();
+```
+
+## Examples
+
+See [`examples/`](./examples) for runnable scripts:
+
+- `quick_start.ts` — minimal projects/run/await flow.
+- `run_stream.ts` — streaming with the subscribe-before-POST race avoidance.
+- `document_upload.ts` — `client.documents.ingest` + run.
+- `with_scoped_token.ts` — mint + browser-style usage.
+- `with_otel.ts` — OpenTelemetry W3C trace propagation.
+
+## Documentation
+
+- Source mirror: <https://github.com/PodestaAI/akribes-sdks>
+- Language guide: <https://akribes.ai/docs>
+
+## License
+
+MIT. See [`LICENSE`](./LICENSE).

package/dist/client.d.ts

@@ -0,0 +1,240 @@
+import { HttpClient, type TracePropagator } from './http';
+import { ProjectsClient } from './sub/projects';
+import { ScriptsClient } from './sub/scripts';
+import { VersionsClient } from './sub/versions';
+import { ChannelsClient } from './sub/channels';
+import { ExecutionsClient } from './sub/executions';
+import { DocumentsClient } from './sub/documents';
+import { ClientsClient, type HeartbeatStatus } from './sub/clients';
+import { TokensClient } from './sub/tokens';
+import { EventsClient } from './sub/events';
+import { EvalsClient } from './sub/evals';
+import { BenchClient } from './sub/bench';
+import { McpClient } from './sub/mcp';
+import type { ConvertResult, EngineEvent } from './types';
+export type AkribesClientOptions = {
+    baseUrl: string;
+    /**
+     * Bearer token sent on every request. There are two valid kinds:
+     *
+     * 1. **Service token** — the secret part of `AKRIBES_SERVICE_TOKEN_<NAME>=<scope>:<secret>`
+     *    from the server's env. Long-lived, never expires, full Admin within
+     *    its project scope. Use this from a trusted backend (e.g. puto's
+     *    server-side code).
+     * 2. **Scoped token** — `akribes_tk_...` (legacy `aura_tk_...` still
+     *    accepted) minted at runtime via
+     *    `akribes.tokens.mint()`. Short-lived, revokable, has a `user_email`
+     *    attached. Use this in browsers, CLIs, or any context where you don't
+     *    want to expose a long-lived secret.
+     *
+     * Update this at runtime via `setToken()` after refreshing.
+     */
+    token?: string;
+    projectId?: number;
+    name?: string;
+    id?: string;
+    /**
+     * Email sent as `X-Akribes-User` header for metrics attribution. Only
+     * honored for service tokens — when a backend with a service token makes
+     * calls on behalf of an end user, set this so usage shows up against that
+     * user. (Servers also accept the legacy `X-Aura-User` form for backwards
+     * compat with pre-rebrand clients, but new code should not rely on that.)
+     *
+     * **This header does not grant any permissions.** Authorization is purely
+     * based on the bearer token's scope.
+     */
+    onBehalfOf?: string;
+    /**
+     * Optional W3C trace-context propagator. When set, the SDK invokes it on
+     * every outbound request so the carrier is populated with `traceparent`
+     * (and optionally `tracestate`) headers. The SDK has zero OpenTelemetry
+     * runtime dependencies; callers pass in an `@opentelemetry/api`-based
+     * injector from their own setup:
+     *
+     * ```ts
+     * import { propagation, context } from '@opentelemetry/api';
+     * new AkribesClient({
+     *   ...,
+     *   propagator: (carrier) => propagation.inject(context.active(), carrier),
+     * });
+     * ```
+     *
+     * Leaving this unset is fine — the server doesn't require a traceparent.
+     */
+    propagator?: TracePropagator;
+    /**
+     * Default poll budget for `documents.ingest()` when the per-call
+     * `pollTimeoutMs` is omitted. Resolution order at construction:
+     *
+     *   1. This option, if set.
+     *   2. `process.env.AKRIBES_SDK_INGEST_TIMEOUT_SECS` × 1000 (Node/Bun only;
+     *      ignored in browsers and when zero/unparseable).
+     *   3. `DEFAULT_INGEST_POLL_TIMEOUT_MS` (1 200 000 ms = 20 min).
+     *
+     * Per-call `IngestOptions.pollTimeoutMs` always wins over this default.
+     */
+    ingestPollTimeoutMs?: number;
+    /**
+     * Invoked when the background heartbeat transitions between states (`ok`,
+     * `unreachable`, `auth_failed`). Fired once per transition — not once per
+     * 30s tick — so a UI can prompt for re-auth on `auth_failed` without an
+     * endless flood of warnings. After receiving `auth_failed`, the heartbeat
+     * stops ticking; call {@link setToken} with a fresh token and then
+     * {@link AkribesClient.clients}`.resumeHeartbeat()` to revive it.
+     *
+     * Resolves #1220 (TS heartbeat silently logged 401/403 forever) and
+     * #1182 (heartbeat backoff parity across SDKs).
+     */
+    onHeartbeatStatus?: (status: HeartbeatStatus) => void;
+};
+/**
+ * Akribes client.
+ *
+ * **Auth quickstart**:
+ *
+ * ```ts
+ * // Backend → talk to akribes-server with your service token
+ * const akribes = new AkribesClient({
+ *   baseUrl: 'https://akribes.example.com',
+ *   token: process.env.AKRIBES_SERVICE_TOKEN!,         // <scope>:<secret>'s secret part
+ *   onBehalfOf: 'customer@acme.com',                // optional, for metrics
+ *   projectId: 2,
+ * });
+ *
+ * // Browser → use a scoped token your backend minted via akribes.tokens.mint()
+ * const akribes = new AkribesClient({
+ *   baseUrl: 'https://akribes.example.com',
+ *   token: 'akribes_tk_xxxx',                       // expires, revokable
+ *   projectId: 2,
+ * });
+ * ```
+ *
+ * See {@link TokensClient} for minting/listing/revoking scoped tokens.
+ */
+export declare class AkribesClient {
+    private options;
+    private http;
+    private token;
+    private _projectId;
+    private _projects;
+    private _scripts?;
+    private _versions?;
+    private _channels?;
+    private _executions?;
+    private _documents?;
+    private _clients?;
+    private _tokens;
+    private _events;
+    private _evals?;
+    private _bench?;
+    private _mcp?;
+    private _state;
+    private _adHocDisposers;
+    constructor(options: AkribesClientOptions);
+    private initProjectScoped;
+    private requireProjectScoped;
+    get projects(): ProjectsClient;
+    get scripts(): ScriptsClient;
+    get versions(): VersionsClient;
+    get channels(): ChannelsClient;
+    get executions(): ExecutionsClient;
+    get documents(): DocumentsClient;
+    get clients(): ClientsClient;
+    get tokens(): TokensClient;
+    /** Hub event subscriptions. Always available — non-project-scoped clients
+     *  receive the global stream (filtered to what the token can see). */
+    get events(): EventsClient;
+    get evals(): EvalsClient;
+    get bench(): BenchClient;
+    get mcp(): McpClient;
+    get state(): StateClient;
+    /**
+     * @deprecated Prefer `client.documents.ingest(filename, bytes, opts)`, which
+     * hash-first-dedups against the server's blob cache and supports progress
+     * callbacks. The legacy `/convert` endpoint remains functional for now.
+     *
+     * Convert a document file to Markdown via Docling.
+     *
+     * When the client is constructed with a `projectId`, the persisted document
+     * is owned by that project and the returned `document_id` can be passed back
+     * as a document input on subsequent runs to skip re-upload + reconversion.
+     * Without a `projectId`, the document (if S3-persisted) has no project owner
+     * and can only be accessed by service tokens. */
+    convert(file: Blob | File, opts?: {
+        signal?: AbortSignal;
+    }): Promise<ConvertResult>;
+    /** Fetch the caller's per-user sandbox project id (creates one on the
+     * server if missing). Use this to subscribe to ad-hoc events *before*
+     * calling `runAdHoc()` so the first engine events aren't missed. */
+    getSandboxProjectId(opts?: {
+        signal?: AbortSignal;
+    }): Promise<number>;
+    /** Execute raw .akr source ad-hoc. Server runs it in the caller's
+     * per-user sandbox project and returns the execution_id + project_id.
+     *
+     * `channel` and `triggeredBy` (#1120) match the Python SDK's `run_adhoc`
+     * parameters: `channel` selects the published-version channel to resolve
+     * `use foo` references against (default: server's default channel);
+     * `triggeredBy` is an opaque identifier recorded with the execution. */
+    runAdHoc(source: string, opts?: {
+        inputs?: Record<string, unknown>;
+        breakpointLines?: number[];
+        channel?: string;
+        triggeredBy?: string;
+        signal?: AbortSignal;
+    }): Promise<{
+        execution_id: string;
+        project_id: number;
+    }>;
+    /** Stream events from ad-hoc executions in the given sandbox project.
+     *
+     * Pass the `project_id` returned from `runAdHoc()` (or
+     * `getSandboxProjectId()`). Returns an unsubscribe function.
+     *
+     * **Avoiding the subscribe-after-POST race.** A fast workflow
+     * (single-digit-millisecond mock providers) can emit `NodeStart`,
+     * `TaskStart`, … before a naive `runAdHoc().then(onAdHocExecution)` has
+     * the SSE subscriber attached on the server side, dropping those opening
+     * events on the broadcast channel. To eliminate the race, pass an
+     * `opts.onReady` callback — it fires once the SSE `GET /events` response
+     * is open (status 2xx) — and only POST `/execute` after it resolves:
+     *
+     * ```ts
+     * const projectId = await client.getSandboxProjectId();
+     * const ready = Promise.withResolvers<void>();
+     * const unsubscribe = client.onAdHocExecution(
+     *   projectId,
+     *   (ev) => { ... },
+     *   { onReady: () => ready.resolve() },
+     * );
+     * await ready.promise;             // SSE attached, safe to POST
+     * await client.runAdHoc(source);
+     * ```
+     *
+     * `onReady` is invoked at most once per call (transparent reconnects do
+     * not re-fire it). If the connection never establishes — bad token, wrong
+     * URL, server down — `onReady` is never called; pair the `await` with a
+     * timeout so a misconfigured callsite fails fast instead of hanging.
+     */
+    onAdHocExecution(projectId: number, callback: (event: EngineEvent) => void, opts?: {
+        onReady?: () => void;
+    }): () => void;
+    /** Update the auth token at runtime (e.g. after refresh). */
+    setToken(token: string | undefined): void;
+    /** Update the X-Akribes-User header for metrics attribution. */
+    setOnBehalfOf(email: string | undefined): void;
+    /** Clean up heartbeat and SSE connections. */
+    destroy(): void;
+}
+declare class StateClient {
+    private http;
+    constructor(http: HttpClient);
+    get(opts?: {
+        signal?: AbortSignal;
+    }): Promise<{
+        env: Record<string, string>;
+    }>;
+}
+export { StateClient };
+export type { HeartbeatStatus } from './sub/clients';
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"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"}