@deepraxis/sdk 0.0.0-stage → 0.1.0-dev.ea77ce8

package/README.md

@@ -1,3 +1,280 @@
-# Temporary Holding Version
+<div align="center">
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+# Praxis TypeScript SDK
+
+**Models, agents, sandboxes, search, data and automation, typed end to end.**
+
+The official TypeScript SDK for [知行云 Praxis](https://deepraxis.com), the cloud where AI agents are built, run and hosted.
+
+[![npm](https://img.shields.io/npm/v/@deepraxis/sdk?label=npm&color=2e8555)](https://www.npmjs.com/package/@deepraxis/sdk)
+[![Bundle size](https://img.shields.io/bundlephobia/minzip/@deepraxis/sdk?color=2e8555)](https://bundlephobia.com/package/@deepraxis/sdk)
+[![License](https://img.shields.io/badge/license-Apache--2.0-2e8555)](https://www.apache.org/licenses/LICENSE-2.0)
+
+[Website](https://deepraxis.com) · [Documentation](https://docs.deepraxis.com) · [API reference](https://docs.deepraxis.com/docs/api) · [Console](https://console.deepraxis.com)
+
+</div>
+
+---
+
+```ts
+import { Praxis } from '@deepraxis/sdk';
+
+const praxis = new Praxis({ apiKey: process.env.PRAXIS_API_KEY! });
+
+const completion = await praxis.model.chat.completions.create({
+  body: {
+    model: 'deepseek-flash',
+    messages: [{ role: 'user', content: 'Hello!' }],
+  },
+});
+console.log(completion.choices[0]?.message.content);
+```
+
+## Why this SDK
+
+- **The whole platform, one client.** About 350 operations across models, agents, sandboxes,
+  cloud browsers, web search, databases, knowledge bases, files, media, automation and hosted
+  applications, generated from the same contract as the API.
+- **Types from the contract.** Every path, query, body and response is typed, including the
+  events of each stream, so your editor knows what comes back.
+- **Zero dependencies, any runtime.** Plain `fetch`: Node.js 20+, Bun, Deno, Cloudflare Workers and
+  browsers, with nothing to polyfill.
+- **Production behavior built in.** Timeouts, retries with backoff that honor `Retry-After`,
+  automatic pagination, cancellation and typed errors carrying a request id.
+
+## Install
+
+```sh
+npm install @deepraxis/sdk     # or: pnpm add / yarn add / bun add
+```
+
+Create an API key in the [Console](https://console.deepraxis.com/keys) and keep it on the
+server. You need a Praxis account; sign up at [deepraxis.com](https://deepraxis.com).
+
+```ts
+const praxis = new Praxis({
+  apiKey: process.env.PRAXIS_API_KEY!,
+  baseUrl: 'https://api.deepraxis.com',  // default
+  timeoutMs: 60_000,   // default; the whole call, body included
+  maxRetries: 2,       // default
+  // fetch: customFetch,  // bring your own fetch
+});
+```
+
+Every method takes one typed object, `{ path, query, body, headers }`, plus optional `signal`,
+`timeoutMs` and `maxRetries` for that call.
+
+## Examples
+
+### Stream a reply
+
+```ts
+const stream = await praxis.model.chat.completions.create({
+  body: {
+    model: 'deepseek-flash',
+    messages: [{ role: 'user', content: 'Count to five' }],
+  },
+  stream: true,
+});
+for await (const chunk of stream) {
+  console.log(chunk.data);
+}
+```
+
+Methods that offer both JSON and server-sent events stream when you pass `stream: true` at the
+top level. Breaking out of the loop cancels the request.
+
+### Run an agent
+
+```ts
+const agent = await praxis.agent.agents.create({
+  body: {
+    name: 'helper',
+    model: { id: 'deepseek-flash' },
+    tools: [{ type: 'agent_toolset_20260401' }],
+  },
+});
+const { sessions } = praxis.agent;
+const session = await sessions.create({
+  body: { agent: agent.id },
+});
+const path = { session_id: session.id };
+
+await sessions.events.send({
+  path,
+  body: {
+    events: [{
+      type: 'user.message',
+      content: [{ type: 'text', text: 'What can you do?' }],
+    }],
+  },
+});
+for await (const event of sessions.events.stream({ path })) {
+  console.log(event.event, event.data);
+}
+```
+
+An agent is a reusable definition: model, instructions and tools. Each session is one
+conversation with it, on its own machine.
+
+### Run code in a sandbox
+
+```ts
+const { sandboxes } = praxis.sandbox;
+const sandbox = await sandboxes.create({
+  body: { templateID: 'base' },
+});
+const result = await sandboxes.commands.run({
+  path: { sandbox_id: sandbox.sandboxID },
+  body: { cmd: "python3 -c 'print(6 * 7)'" },
+});
+console.log(result);
+await sandboxes.delete({ path: { sandboxID: sandbox.sandboxID } });
+```
+
+### Search the web
+
+```ts
+const { results } = await praxis.search.search.create({
+  body: { query: 'AI agent frameworks', max_results: 5 },
+});
+for (const r of results ?? []) console.log(r.title, r.url);
+```
+
+### Run a script and wait for it
+
+```ts
+const run = await praxis.automation.runs.create({
+  body: {
+    source: `export default async (input: { n: number }) =>
+      ({ answer: input.n + 1 });`,
+    language: 'ts',
+    input: { n: 41 },
+    wait: 60,
+  },
+  headers: { 'Idempotency-Key': crypto.randomUUID() },
+  timeoutMs: 90_000,
+});
+console.log(run.status, run.output);
+```
+
+`wait` is how long the server holds the request, in seconds. A run that is still going comes
+back unfinished; read it again with `praxis.automation.runs.retrieve({ path: { id: run.id } })`.
+A successful HTTP response does not mean the script succeeded, so check `status`.
+
+## Pagination
+
+```ts
+const page = await praxis.automation.runs.list({
+  query: { limit: 20 },
+});
+console.log(page.data, page.next_cursor);  // this page only
+for await (const run of page) {
+  console.log(run.id);  // every page, fetched as you go
+}
+const next = await page.nextPage();  // next Page, or null
+```
+
+Lists with a `cursor` contract return a `Page`. Iteration keeps your filters, headers and
+cancellation, and gives each page its own timeout. Other lists keep the response shape of their
+API; [METHODS.md](https://unpkg.com/@deepraxis/sdk/METHODS.md) marks which is which.
+
+## Errors and retries
+
+```ts
+import {
+  PraxisError, PraxisConnectionError, PraxisTimeoutError,
+} from '@deepraxis/sdk';
+
+try {
+  await praxis.automation.runs.list({ query: { limit: 0 } });
+} catch (error) {
+  if (error instanceof PraxisTimeoutError) {
+    console.error('Request timed out');
+  } else if (error instanceof PraxisConnectionError) {
+    console.error('Connection failed');
+  } else if (error instanceof PraxisError) {
+    const { status, code, detail, requestId } = error;
+    console.error(status, code, detail, requestId);
+  } else {
+    throw error; // includes your own cancellation
+  }
+}
+```
+
+`PraxisError` carries the problem details of the response: `status`, `code`, `type`, `title`,
+`detail`, `errors` and `requestId`. Quote the request id when you contact support.
+
+The SDK retries 408, 429, 5xx and connection failures with exponential backoff and jitter, and
+waits as long as `Retry-After` asks. **A POST is retried only when it has an `Idempotency-Key`**,
+so a retry can never run an action twice. The call's timeout bounds the retries too.
+
+## Server-sent events
+
+Streams such as `automation.runs.events`, `automation.runs.logs` and agent session events return
+an `AsyncIterable` directly. Each frame has optional `id` and `event`; `data` is parsed as JSON
+when possible. To resume after a disconnect, pass the last `id` you saw:
+
+```ts
+let lastEventId: string | undefined;
+const events = praxis.automation.runs.events({
+  path: { id: run.id },
+  lastEventId,
+});
+for await (const event of events) {
+  lastEventId = event.id ?? lastEventId;
+  console.log(event.event, event.data);
+}
+```
+
+`parseSSE` is exported for streams you read yourself.
+
+## Smaller bundles
+
+Import one domain when that is all you need:
+
+```ts
+import { createAutomationClient } from '@deepraxis/sdk/automation';
+
+const automation = createAutomationClient({
+  apiKey: process.env.PRAXIS_API_KEY!,
+});
+const runs = await automation.runs.list();
+```
+
+Schema types are available from `@deepraxis/sdk/types`.
+
+## Inside a Praxis script
+
+Hosted automation scripts already have `praxis` and `call` in scope. Don't install the SDK there:
+
+```ts
+export default async (input: { prompt: string }) => {
+  return await call('praxis/chat', {
+    model: 'deepseek-flash',
+    messages: [{ role: 'user', content: input.prompt }],
+    stream: false,
+  });
+};
+```
+
+## Already using the OpenAI or Anthropic SDK?
+
+Keep your code and point the official SDK at Praxis by changing `baseURL`, for example
+`https://api.deepraxis.com/openai/v1` for the OpenAI SDK. The
+[SDK cookbook](https://docs.deepraxis.com/docs/cookbook/sdk) has the details for OpenAI,
+Anthropic, the Vercel AI SDK and LangChain. This SDK covers what those don't: agents,
+sandboxes, search, data, automation and the rest of the platform.
+
+## Resources
+
+- [Documentation](https://docs.deepraxis.com) and [API reference](https://docs.deepraxis.com/docs/api)
+- [METHODS.md](https://unpkg.com/@deepraxis/sdk/METHODS.md): every method, its HTTP route, and whether it streams or paginates
+- [Praxis CLI](https://www.npmjs.com/package/@deepraxis/cli): the same API from your terminal
+
+## License
+
+[Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0). Copyright 2026 南京深度实践人工智能科技有限公司 (Deepractice).
+
+"Praxis", "知行云" and "Deepraxis" are trademarks of Deepractice; the license does not grant
+rights to use them.

package/dist/automation.d.ts

@@ -0,0 +1,151 @@
+import { type PraxisOptions } from './core/transport.js';
+/** An automation-only entry point: other resource factories tree-shake away. */
+export declare function createAutomationClient(options: PraxisOptions): {
+    actions: {
+        archive: (options: import("./core/transport.js").CallOptions<import("./generated/types.gen.js").AutomationActionsArchiveData>) => Promise<import("./generated/types.gen.js").AutomationActionArchiveResult>;
+        create: (options: import("./core/transport.js").CallOptions<import("./generated/types.gen.js").AutomationActionsCreateData>) => Promise<import("./generated/types.gen.js").AutomationActionDef>;
+        dependents: {
+            list: (options: import("./core/transport.js").CallOptions<import("./generated/types.gen.js").AutomationActionsDependentsData>) => Promise<import("./automation.js").Page<import("./generated/types.gen.js").AutomationDependent>>;
+        };
+        invocations: {
+            list: (options: import("./core/transport.js").CallOptions<import("./generated/types.gen.js").AutomationActionsInvocationsData>) => Promise<import("./automation.js").Page<import("./generated/types.gen.js").AutomationInvocation>>;
+        };
+        list: (options?: import("./core/transport.js").CallOptions<import("./generated/types.gen.js").AutomationActionsListData> | undefined) => Promise<import("./automation.js").Page<import("./generated/types.gen.js").AutomationActionListItem>>;
+        restore: (options: import("./core/transport.js").CallOptions<import("./generated/types.gen.js").AutomationActionsRestoreData>) => Promise<import("./generated/types.gen.js").AutomationActionDef>;
+        retrieve: (options: import("./core/transport.js").CallOptions<import("./generated/types.gen.js").AutomationActionsGetData>) => Promise<import("./generated/types.gen.js").AutomationActionDef>;
+        revisions: {
+            list: (options: import("./core/transport.js").CallOptions<import("./generated/types.gen.js").AutomationActionsRevisionsData>) => Promise<import("./automation.js").Page<import("./generated/types.gen.js").AutomationRevisionSummary>>;
+            retrieve: (options: import("./core/transport.js").CallOptions<import("./generated/types.gen.js").AutomationActionsRevisionData>) => Promise<import("./generated/types.gen.js").AutomationRevisionListItem>;
+        };
+        rollback: (options: import("./core/transport.js").CallOptions<import("./generated/types.gen.js").AutomationActionsRollbackData>) => Promise<import("./generated/types.gen.js").AutomationActionDef>;
+        update: (options: import("./core/transport.js").CallOptions<import("./generated/types.gen.js").AutomationActionsUpdateData>) => Promise<import("./generated/types.gen.js").AutomationActionUpdateResult>;
+    };
+    hooks: {
+        send: (options: import("./core/transport.js").CallOptions<import("./generated/types.gen.js").AutomationHooksReceiveData>) => Promise<import("./generated/types.gen.js").AutomationFiring>;
+    };
+    resolve: {
+        retrieve: (options: import("./core/transport.js").CallOptions<import("./generated/types.gen.js").AutomationResolveResolveData>) => Promise<import("./generated/types.gen.js").AutomationResolveResult>;
+    };
+    runs: {
+        artifacts: {
+            list: (options: import("./core/transport.js").CallOptions<import("./generated/types.gen.js").AutomationRunsArtifactsData>) => Promise<import("./automation.js").Page<import("./generated/types.gen.js").AutomationRunArtifact>>;
+        };
+        calls: {
+            list: (options: import("./core/transport.js").CallOptions<import("./generated/types.gen.js").AutomationRunsCallsData>) => Promise<import("./automation.js").Page<import("./generated/types.gen.js").AutomationCall>>;
+        };
+        cancel: (options: import("./core/transport.js").CallOptions<import("./generated/types.gen.js").AutomationRunsCancelData>) => Promise<import("./generated/types.gen.js").AutomationRun>;
+        create: (options: import("./core/transport.js").CallOptions<import("./generated/types.gen.js").AutomationRunsCreateData>) => Promise<import("./generated/types.gen.js").AutomationRun>;
+        events: (options: import("./core/transport.js").StreamOptions<import("./generated/types.gen.js").AutomationRunsEventsData>) => AsyncIterable<import("./generated/types.gen.js").PraxisSdkSseGetAutomationV1RunsIdEvents>;
+        list: (options?: import("./core/transport.js").CallOptions<import("./generated/types.gen.js").AutomationRunsListData> | undefined) => Promise<import("./automation.js").Page<import("./generated/types.gen.js").AutomationRun>>;
+        logs: (options: import("./core/transport.js").StreamOptions<import("./generated/types.gen.js").AutomationRunsLogsData>) => AsyncIterable<import("./generated/types.gen.js").PraxisSdkSseGetAutomationV1RunsIdLogs>;
+        rerun: (options: import("./core/transport.js").CallOptions<import("./generated/types.gen.js").AutomationRunsRerunData>) => Promise<import("./generated/types.gen.js").AutomationRun>;
+        resume: (options: import("./core/transport.js").CallOptions<import("./generated/types.gen.js").AutomationRunsResumeData>) => Promise<import("./generated/types.gen.js").AutomationRun>;
+        retrieve: (options: import("./core/transport.js").CallOptions<import("./generated/types.gen.js").AutomationRunsGetData>) => Promise<import("./generated/types.gen.js").AutomationExpandedRun>;
+        retrieveSource: (options: import("./core/transport.js").CallOptions<import("./generated/types.gen.js").AutomationRunsSourceData>) => Promise<{
+            language: import("./generated/types.gen.js").AutomationSourceLanguage;
+            source: string;
+            sha256: string;
+        }>;
+        suspend: (options: import("./core/transport.js").CallOptions<import("./generated/types.gen.js").AutomationRunsSuspendData>) => Promise<import("./generated/types.gen.js").AutomationRun>;
+        tasks: {
+            list: (options: import("./core/transport.js").CallOptions<import("./generated/types.gen.js").AutomationRunsTasksData>) => Promise<import("./automation.js").Page<import("./generated/types.gen.js").AutomationTask | import("./generated/types.gen.js").AutomationTaskGroup>>;
+        };
+        waits: {
+            complete: (options: import("./core/transport.js").CallOptions<import("./generated/types.gen.js").AutomationRunsCompleteWaitData>) => Promise<{
+                id: string;
+                run_id: string;
+                kind: "event" | "timer" | "child";
+                state: "cancelled" | "open" | "resolved" | "expired";
+                task: null | {
+                    reference: string;
+                    name: string;
+                };
+                resume_at: null | string;
+                event_type: null | string;
+                child_run_id: null | string;
+                created_at: string;
+                expires_at: null | string;
+                resolved_at: null | string;
+                replayed: boolean;
+            }>;
+            list: (options: import("./core/transport.js").CallOptions<import("./generated/types.gen.js").AutomationRunsWaitsData>) => Promise<import("./automation.js").Page<import("./generated/types.gen.js").AutomationWait>>;
+        };
+    };
+    scripts: {
+        archive: (options: import("./core/transport.js").CallOptions<import("./generated/types.gen.js").AutomationScriptsArchiveData>) => Promise<import("./generated/types.gen.js").AutomationDefinition>;
+        create: (options: import("./core/transport.js").CallOptions<import("./generated/types.gen.js").AutomationScriptsCreateData>) => Promise<import("./generated/types.gen.js").AutomationDefinitionDetail>;
+        distTags: {
+            delete: (options: import("./core/transport.js").CallOptions<import("./generated/types.gen.js").AutomationScriptsDeleteDistTagData>) => Promise<{
+                [key: string]: import("./generated/types.gen.js").AutomationDistTag;
+            }>;
+            list: (options: import("./core/transport.js").CallOptions<import("./generated/types.gen.js").AutomationScriptsDistTagsData>) => Promise<{
+                [key: string]: import("./generated/types.gen.js").AutomationDistTag;
+            }>;
+            set: (options: import("./core/transport.js").CallOptions<import("./generated/types.gen.js").AutomationScriptsSetDistTagData>) => Promise<{
+                [key: string]: import("./generated/types.gen.js").AutomationDistTag;
+            }>;
+        };
+        list: (options?: import("./core/transport.js").CallOptions<import("./generated/types.gen.js").AutomationScriptsListData> | undefined) => Promise<import("./automation.js").Page<import("./generated/types.gen.js").AutomationDefinition>>;
+        restore: (options: import("./core/transport.js").CallOptions<import("./generated/types.gen.js").AutomationScriptsRestoreData>) => Promise<import("./generated/types.gen.js").AutomationDefinition>;
+        retrieve: (options: import("./core/transport.js").CallOptions<import("./generated/types.gen.js").AutomationScriptsGetData>) => Promise<import("./generated/types.gen.js").AutomationDefinitionDetail>;
+        update: (options: import("./core/transport.js").CallOptions<import("./generated/types.gen.js").AutomationScriptsPatchData>) => Promise<import("./generated/types.gen.js").AutomationDefinitionDetail>;
+        versions: {
+            create: (options: import("./core/transport.js").CallOptions<import("./generated/types.gen.js").AutomationScriptsPublishData>) => Promise<import("./generated/types.gen.js").AutomationVersion>;
+            deprecate: (options: import("./core/transport.js").CallOptions<import("./generated/types.gen.js").AutomationScriptsDeprecateData>) => Promise<import("./generated/types.gen.js").AutomationVersion>;
+            list: (options: import("./core/transport.js").CallOptions<import("./generated/types.gen.js").AutomationScriptsVersionsData>) => Promise<import("./automation.js").Page<import("./generated/types.gen.js").AutomationVersionListItem>>;
+            publish: (options: import("./core/transport.js").CallOptions<import("./generated/types.gen.js").AutomationScriptsPublishData>) => Promise<import("./generated/types.gen.js").AutomationVersion>;
+            retrieve: (options: import("./core/transport.js").CallOptions<import("./generated/types.gen.js").AutomationScriptsVersionData>) => Promise<import("./generated/types.gen.js").AutomationVersion>;
+        };
+    };
+    targets: {
+        list: (options?: import("./core/transport.js").CallOptions<import("./generated/types.gen.js").AutomationTargetsTargetsData> | undefined) => Promise<import("./automation.js").Page<import("./generated/types.gen.js").AutomationTargetHit>>;
+    };
+    triggers: {
+        create: (options: import("./core/transport.js").CallOptions<import("./generated/types.gen.js").AutomationTriggersCreateData>) => Promise<import("./generated/types.gen.js").AutomationTriggerCreateResult>;
+        delete: (options: import("./core/transport.js").CallOptions<import("./generated/types.gen.js").AutomationTriggersDeleteData>) => Promise<void>;
+        fire: (options: import("./core/transport.js").CallOptions<import("./generated/types.gen.js").AutomationTriggersFireData>) => Promise<import("./generated/types.gen.js").AutomationFiring>;
+        firings: {
+            list: (options: import("./core/transport.js").CallOptions<import("./generated/types.gen.js").AutomationTriggersFiringsData>) => Promise<import("./automation.js").Page<import("./generated/types.gen.js").AutomationFiring>>;
+        };
+        list: (options?: import("./core/transport.js").CallOptions<import("./generated/types.gen.js").AutomationTriggersListData> | undefined) => Promise<import("./automation.js").Page<import("./generated/types.gen.js").AutomationTrigger>>;
+        pause: (options: import("./core/transport.js").CallOptions<import("./generated/types.gen.js").AutomationTriggersPauseData>) => Promise<import("./generated/types.gen.js").AutomationTrigger>;
+        preview: (options: import("./core/transport.js").CallOptions<import("./generated/types.gen.js").AutomationTriggersPreviewData>) => Promise<import("./generated/types.gen.js").AutomationTriggerPreview>;
+        resume: (options: import("./core/transport.js").CallOptions<import("./generated/types.gen.js").AutomationTriggersResumeData>) => Promise<import("./generated/types.gen.js").AutomationTrigger>;
+        retrieve: (options: import("./core/transport.js").CallOptions<import("./generated/types.gen.js").AutomationTriggersGetData>) => Promise<import("./generated/types.gen.js").AutomationTrigger>;
+        rotateWebhook: (options: import("./core/transport.js").CallOptions<import("./generated/types.gen.js").AutomationTriggersRotateWebhookData>) => Promise<import("./generated/types.gen.js").AutomationWebhookUrl>;
+        update: (options: import("./core/transport.js").CallOptions<import("./generated/types.gen.js").AutomationTriggersPatchData>) => Promise<import("./generated/types.gen.js").AutomationTrigger>;
+    };
+    validate: {
+        create: (options: import("./core/transport.js").CallOptions<import("./generated/types.gen.js").AutomationValidateValidateData>) => Promise<import("./generated/types.gen.js").AutomationValidateResult>;
+    };
+    workflows: {
+        archive: (options: import("./core/transport.js").CallOptions<import("./generated/types.gen.js").AutomationWorkflowsArchiveData>) => Promise<import("./generated/types.gen.js").AutomationDefinition>;
+        create: (options: import("./core/transport.js").CallOptions<import("./generated/types.gen.js").AutomationWorkflowsCreateData>) => Promise<import("./generated/types.gen.js").AutomationDefinitionDetail>;
+        distTags: {
+            delete: (options: import("./core/transport.js").CallOptions<import("./generated/types.gen.js").AutomationWorkflowsDeleteDistTagData>) => Promise<{
+                [key: string]: import("./generated/types.gen.js").AutomationDistTag;
+            }>;
+            list: (options: import("./core/transport.js").CallOptions<import("./generated/types.gen.js").AutomationWorkflowsDistTagsData>) => Promise<{
+                [key: string]: import("./generated/types.gen.js").AutomationDistTag;
+            }>;
+            set: (options: import("./core/transport.js").CallOptions<import("./generated/types.gen.js").AutomationWorkflowsSetDistTagData>) => Promise<{
+                [key: string]: import("./generated/types.gen.js").AutomationDistTag;
+            }>;
+        };
+        list: (options?: import("./core/transport.js").CallOptions<import("./generated/types.gen.js").AutomationWorkflowsListData> | undefined) => Promise<import("./automation.js").Page<import("./generated/types.gen.js").AutomationDefinition>>;
+        restore: (options: import("./core/transport.js").CallOptions<import("./generated/types.gen.js").AutomationWorkflowsRestoreData>) => Promise<import("./generated/types.gen.js").AutomationDefinition>;
+        retrieve: (options: import("./core/transport.js").CallOptions<import("./generated/types.gen.js").AutomationWorkflowsGetData>) => Promise<import("./generated/types.gen.js").AutomationDefinitionDetail>;
+        update: (options: import("./core/transport.js").CallOptions<import("./generated/types.gen.js").AutomationWorkflowsPatchData>) => Promise<import("./generated/types.gen.js").AutomationDefinitionDetail>;
+        versions: {
+            create: (options: import("./core/transport.js").CallOptions<import("./generated/types.gen.js").AutomationWorkflowsPublishData>) => Promise<import("./generated/types.gen.js").AutomationVersion>;
+            deprecate: (options: import("./core/transport.js").CallOptions<import("./generated/types.gen.js").AutomationWorkflowsDeprecateData>) => Promise<import("./generated/types.gen.js").AutomationVersion>;
+            list: (options: import("./core/transport.js").CallOptions<import("./generated/types.gen.js").AutomationWorkflowsVersionsData>) => Promise<import("./automation.js").Page<import("./generated/types.gen.js").AutomationVersionListItem>>;
+            publish: (options: import("./core/transport.js").CallOptions<import("./generated/types.gen.js").AutomationWorkflowsPublishData>) => Promise<import("./generated/types.gen.js").AutomationVersion>;
+            retrieve: (options: import("./core/transport.js").CallOptions<import("./generated/types.gen.js").AutomationWorkflowsVersionData>) => Promise<import("./generated/types.gen.js").AutomationVersion>;
+        };
+    };
+};
+export { PraxisError, PraxisConnectionError, PraxisTimeoutError } from './core/errors.js';
+export type { PraxisOptions, RequestOptions } from './core/transport.js';
+export type { SSEEvent } from './core/sse.js';
+export { Page } from './core/pagination.js';

package/dist/automation.js

@@ -0,0 +1,8 @@
+import { createAutomation } from "./resources.generated.js";
+import { Transport } from "./core/transport.js";
+/** An automation-only entry point: other resource factories tree-shake away. */
+export function createAutomationClient(options) {
+    return createAutomation(new Transport(options));
+}
+export { PraxisError, PraxisConnectionError, PraxisTimeoutError } from "./core/errors.js";
+export { Page } from "./core/pagination.js";

package/dist/core/bindings.d.ts

@@ -0,0 +1,25 @@
+import { Page } from './pagination.js';
+import type { SSEEvent } from './sse.js';
+import type { CallOptions, StreamOptions, Operation, Transport } from './transport.js';
+type Args<D> = {} extends CallOptions<D> ? [options?: CallOptions<D>] : [options: CallOptions<D>];
+type StreamArgs<D> = {} extends StreamOptions<D> ? [options?: StreamOptions<D>] : [options: StreamOptions<D>];
+export declare function bind<D, R>(transport: Transport, operation: Operation): (...args: Args<D>) => Promise<R>;
+export declare function bindStream<D, E extends SSEEvent = SSEEvent>(transport: Transport, operation: Operation): (...args: StreamArgs<D>) => AsyncIterable<E>;
+export declare function bindPage<D, T>(transport: Transport, operation: Operation): (...args: Args<D>) => Promise<Page<T>>;
+export interface MixedMethod<D, R, E extends SSEEvent = SSEEvent> {
+    (options: StreamOptions<D> & {
+        stream: true;
+    }): AsyncIterable<E>;
+    (...args: Args<D>): Promise<R>;
+}
+export declare function bindMixed<D, R, E extends SSEEvent = SSEEvent>(transport: Transport, operation: Operation): MixedMethod<D, R, E>;
+/** Project only SDK parameter names; wire names remain hey-api's responsibility. */
+type AliasMap = Record<string, Record<string, string>>;
+type RenameFields<T, A> = T extends object ? {
+    [K in keyof T as K extends keyof A ? A[K] & string : K]: T[K];
+} : T;
+export type RenameParameters<D, A extends AliasMap> = {
+    [K in keyof D]: K extends keyof A ? RenameFields<D[K], A[K]> : D[K];
+};
+export declare function aliasOperation(operation: Operation, aliases: AliasMap): Operation;
+export {};

package/dist/core/bindings.js

@@ -0,0 +1,45 @@
+import { Page } from "./pagination.js";
+export function bind(transport, operation) {
+    return (...args) => transport.request(operation, args[0]);
+}
+export function bindStream(transport, operation) {
+    return (...args) => transport.stream(operation, args[0]);
+}
+export function bindPage(transport, operation) {
+    return async (...args) => {
+        const options = args[0] ?? {};
+        const load = async (cursor) => {
+            const query = 'query' in options ? options.query : {};
+            const value = await transport.request(operation, { ...options, query: { ...query, ...(cursor === undefined ? {} : { cursor }) } });
+            return new Page(value, load);
+        };
+        return load();
+    };
+}
+export function bindMixed(transport, operation) {
+    return ((options = {}) => {
+        if (!options.stream)
+            return transport.request(operation, options);
+        const body = 'body' in options && options.body && typeof options.body === 'object' ? { ...options.body, stream: true } : 'body' in options ? options.body : undefined;
+        return transport.stream(operation, { ...options, body });
+    });
+}
+export function aliasOperation(operation, aliases) {
+    return options => {
+        const mapped = { ...options };
+        for (const [location, names] of Object.entries(aliases)) {
+            if (!options[location])
+                continue;
+            mapped[location] = { ...options[location] };
+            for (const [wire, sdk] of Object.entries(names)) {
+                if (!Object.hasOwn(mapped[location], sdk))
+                    continue;
+                if (Object.hasOwn(mapped[location], wire))
+                    throw new TypeError(`Use only the SDK parameter ${location}.${sdk}`);
+                mapped[location][wire] = mapped[location][sdk];
+                delete mapped[location][sdk];
+            }
+        }
+        return operation(mapped);
+    };
+}

package/dist/core/client.d.ts

@@ -0,0 +1,15 @@
+import { resourceFactories } from '../resources.generated.js';
+import { type PraxisOptions } from './transport.js';
+import { type PublishInput, type PublishResult } from '../helpers/application-publish.js';
+type Resources = {
+    readonly [K in keyof typeof resourceFactories]: ReturnType<(typeof resourceFactories)[K]>;
+};
+export interface Praxis extends Omit<Resources, 'application'> {
+    readonly application: Resources['application'] & {
+        publish(input: PublishInput): Promise<PublishResult>;
+    };
+}
+export declare class Praxis {
+    constructor(options: PraxisOptions);
+}
+export type { PraxisOptions, RequestOptions } from './transport.js';

package/dist/core/client.js

@@ -0,0 +1,15 @@
+import { resourceFactories } from "../resources.generated.js";
+import { Transport } from "./transport.js";
+import { publish } from "../helpers/application-publish.js";
+export class Praxis {
+    constructor(options) {
+        const transport = new Transport(options);
+        for (const [name, create] of Object.entries(resourceFactories)) {
+            const resource = create(transport);
+            // Assemble before sealing the resource property; never replace a readonly SDK resource.
+            if (name === 'application')
+                Object.assign(resource, { publish: (input) => publish(this, input) });
+            Object.defineProperty(this, name, { value: resource, enumerable: true });
+        }
+    }
+}

package/dist/core/credentials.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Default credential chain for code running on a Praxis computer (ticket-5367):
+ * PRAXIS_API_TOKEN environment variable, then ~/.praxis/credentials. Resolved at call time so a
+ * token the platform renewed in the file is picked up by an already-running process.
+ */
+export interface ResolvedCredentials {
+    token?: string;
+    apiUrl?: string;
+}
+type Env = Record<string, string | undefined>;
+type ReadFile = (path: string) => string | null;
+export declare function credentialsPath(env: Env): string | null;
+export declare function resolveDefaultCredentials(env?: Env, readFile?: ReadFile): ResolvedCredentials;
+export {};

package/dist/core/credentials.js

@@ -0,0 +1,33 @@
+const nonEmpty = (value) => typeof value === 'string' && value ? value : undefined;
+function defaultReadFile(path) {
+    try {
+        const fs = globalThis.process?.getBuiltinModule?.('node:fs');
+        return fs ? fs.readFileSync(path, 'utf8') : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function credentialsPath(env) {
+    const home = nonEmpty(env.HOME) ?? nonEmpty(env.USERPROFILE);
+    return home ? `${home.replace(/\/$/, '')}/.praxis/credentials` : null;
+}
+export function resolveDefaultCredentials(env = globalThis.process?.env ?? {}, readFile = defaultReadFile) {
+    const envToken = nonEmpty(env.PRAXIS_API_TOKEN);
+    const envUrl = nonEmpty(env.PRAXIS_API_URL);
+    if (envToken)
+        return { token: envToken, ...(envUrl ? { apiUrl: envUrl } : {}) };
+    const path = credentialsPath(env);
+    const text = path ? readFile(path) : null;
+    if (!text)
+        return envUrl ? { apiUrl: envUrl } : {};
+    try {
+        const file = JSON.parse(text);
+        const token = nonEmpty(file.token);
+        const apiUrl = envUrl ?? nonEmpty(file.api_url);
+        return { ...(token ? { token } : {}), ...(apiUrl ? { apiUrl } : {}) };
+    }
+    catch {
+        return envUrl ? { apiUrl: envUrl } : {};
+    }
+}

package/dist/core/errors.d.ts

@@ -0,0 +1,38 @@
+/** RFC 9457 problem details, including Praxis's stable machine-readable code. */
+export interface ProblemDetails {
+    status?: number;
+    code?: string;
+    type?: string;
+    title?: string;
+    detail?: string;
+    errors?: unknown[];
+    requestId?: string;
+    message?: string;
+    param?: string | null;
+    raw?: unknown;
+}
+/** Pure normalization shared by HTTP clients and the automation call ledger.
+ * Numeric transport codes (E2B's `code: 400`) are not domain error codes.
+ */
+export declare function problemFrom(status: number, headers: Pick<Headers, 'get'>, body: unknown, statusText?: string): ProblemDetails & {
+    message: string;
+};
+export declare class PraxisError extends Error {
+    readonly status?: number;
+    readonly code?: string;
+    readonly type?: string;
+    readonly title?: string;
+    readonly detail?: string;
+    readonly errors: unknown[];
+    readonly requestId?: string;
+    readonly param?: string | null;
+    readonly raw?: unknown;
+    constructor(problem?: ProblemDetails, options?: ErrorOptions);
+    static fromResponse(response: Response, body: unknown): PraxisError;
+}
+export declare class PraxisConnectionError extends PraxisError {
+    constructor(cause?: unknown);
+}
+export declare class PraxisTimeoutError extends PraxisError {
+    constructor(timeoutMs: number);
+}