@happyrobot-ai/sdk 0.1.3 → 0.1.4

package/README.md

@@ -115,12 +115,14 @@ const { workflow } = await createFromTemplate(client, {
 | `client.mcp` | `MCPResource` | MCP server management |
 | `client.billing` | `BillingResource` | Billing usage details and totals |
 | `client.apiKey` | `ApiKeyResource` | API key introspection |
+| `client.artifacts` | `ArtifactsResource` | Resolve fresh artifact URLs |
 | `client.adversarialSuites` | `AdversarialSuitesResource` | Adversarial suite management and execution |
 | `client.adversarialTests` | `AdversarialTestsResource` | Adversarial test management and execution |
 | `client.northstars` | `NorthstarsResource` | Northstar quality criteria management |
 | `client.customEvals` | `CustomEvalsResource` | Custom eval management and execution |
 | `client.issues` | `IssuesResource` | Quality issue (flag) status management |
 | `client.auditRemarks` | `AuditRemarksResource` | Audit remark feedback management |
+| `client.chat` | `ChatResource` | Chat session management, messaging, and file uploads |
 
 ---
 
@@ -300,6 +302,20 @@ await client.messages.createFlag("message-id", { type: "incorrect", note: "..."
 
 ---
 
+## `client.artifacts`
+
+```ts
+const resolved = await client.artifacts.resolve({
+  s3_keys: ["artifacts/<media_id>/extracted_text.txt"],
+});
+```
+
+| Method | HTTP | Path | Description |
+|---|---|---|---|
+| `resolve(body)` | POST | `/artifacts/resolve` | Resolve fresh presigned URLs for artifacts |
+
+---
+
 ## `client.variables`
 
 Variables are scoped to a workflow.
@@ -706,6 +722,154 @@ await client.auditRemarks.deleteFeedback("audit-remark-id");
 
 ---
 
+## Chat (`client.chat` + `HappyRobotChatClient`)
+
+Build custom chat UIs powered by your workflows. Uses a two-tier auth model:
+
+1. **Your server** creates a scoped client token using the API key (keeps it secret)
+2. **Your browser** uses `HappyRobotChatClient` with that token for all chat operations
+
+### Server-side: Create a client token
+
+```ts
+// --- YOUR SERVER (e.g. Next.js API route, Express handler) ---
+import { HappyRobotClient } from "@happyrobot-ai/sdk";
+
+const client = new HappyRobotClient({ apiKey: process.env.HAPPYROBOT_API_KEY });
+
+app.post("/api/chat-token", async (req, res) => {
+  const { token, expires_at } = await client.chat.createToken({
+    workflow_id: "your-workflow-id",
+  });
+  res.json({ token, expires_at });
+});
+```
+
+### Browser-side: `HappyRobotChatClient`
+
+```ts
+// --- YOUR BROWSER CODE (React, Vue, vanilla JS, etc.) ---
+import { HappyRobotChatClient } from "@happyrobot-ai/sdk";
+
+// 1. Get a client token from your server
+const { token } = await fetch("/api/chat-token", { method: "POST" }).then(r => r.json());
+
+// 2. Initialize the browser-side client
+const chat = new HappyRobotChatClient({ token });
+
+// 3. Create a session
+const { session_id } = await chat.createSession();
+
+// 4. Connect bidirectional WebSocket
+const connection = chat.connect(session_id, {
+  onResponseStart: () => {
+    // Show typing indicator
+  },
+  onResponseChunk: (content) => {
+    // Append streamed text to the UI
+  },
+  onResponseEnd: (content) => {
+    // Full response complete — hide typing indicator
+  },
+  onSessionClosed: (event) => {
+    // Session ended: event.status, event.reason, event.duration
+  },
+  onTokenExpired: () => {
+    // Token expired — fetch a new token from your server and reconnect
+  },
+});
+
+// 5. Send messages through the WebSocket
+const ack = await connection.sendMessage({ content: "Hello!" });
+console.log(ack.message.id); // server-assigned message ID
+
+// 6. Send messages with file attachments
+const artifact = await chat.uploadFile(fileBlob, "photo.png", "image/png");
+await connection.sendMessage({ content: "Here's the photo", artifacts: [artifact] });
+
+// 7. Get history (page reload, reconnect)
+const { messages } = await chat.getHistory(session_id);
+
+// 8. Clean up
+connection.close();
+```
+
+### Browser-side: File uploads
+
+```ts
+// Option A: Use the convenience method (handles all 3 steps)
+const artifact = await chat.uploadFile(fileBlob, "photo.png", "image/png");
+await connection.sendMessage({
+  content: "Here's the photo",
+  artifacts: [artifact],
+});
+
+// Option B: Manual 3-step flow for more control
+const upload = await chat.getPresignedUpload({ filename: "photo.png", mime_type: "image/png" });
+await fetch(upload.upload_url, { method: "PUT", body: fileBlob, headers: { "Content-Type": "image/png" } });
+await chat.completeUpload({
+  artifact_id: upload.artifact_id,
+  s3_uri: upload.s3_uri,
+  filename: "photo.png",
+  mime_type: "image/png",
+  size_bytes: fileBlob.size,
+});
+await connection.sendMessage({
+  content: "Here's the photo",
+  artifacts: [{ media_id: upload.artifact_id, mime_type: "image/png", filename: "photo.png", size_bytes: fileBlob.size }],
+});
+```
+
+### `HappyRobotClient` (server-side)
+
+| Method | Description |
+|---|---|
+| `client.chat.createToken({ workflow_id, env? })` | Create a scoped client token (1 hour expiry) |
+
+### `HappyRobotChatClient` (browser-side)
+
+| Method | Description |
+|---|---|
+| `chat.createSession()` | Create a new chat session |
+| `chat.connect(sessionId, handlers)` | Open bidirectional WebSocket — returns `ChatConnection` |
+| `chat.sendMessage(sessionId, { content, artifacts? })` | Send a user message via HTTP (fallback if WS unavailable) |
+| `chat.getHistory(sessionId)` | Get message history |
+| `chat.uploadFile(file, filename, mimeType)` | Upload a file (convenience method) |
+| `chat.getPresignedUpload({ filename, mime_type })` | Get presigned S3 upload URL |
+| `chat.completeUpload({ artifact_id, s3_uri, ... })` | Register uploaded artifact |
+
+### `ChatConnection`
+
+| Method | Description |
+|---|---|
+| `connection.sendMessage({ content, artifacts? })` | Send a message via WebSocket. Returns a `Promise` that resolves with the server ack |
+| `connection.close()` | Close the WebSocket connection |
+| `connection.ws` | The underlying `WebSocket` instance |
+
+### WebSocket Events
+
+**Server → Client:**
+
+| Event | Fields | Description |
+|---|---|---|
+| `connected` | `session_id` | Connection established |
+| `response-start` | `content` | AI started generating a response |
+| `response-chunk` | `content` | Partial response text |
+| `response-end` | `content` | Complete response text |
+| `session-closed` | `session_id`, `status`, `reason`, `duration`, `timestamp` | Session ended |
+| `token-expired` | — | JWT expired — reconnect with a fresh token |
+| `message-ack` | `id`, `message` | Server confirmed the message was sent |
+| `message-error` | `id`, `error` | Server failed to send the message |
+| `heartbeat` | — | Keep-alive (every 15s) |
+
+**Client → Server:**
+
+| Event | Fields | Description |
+|---|---|---|
+| `message` | `content`, `artifacts?`, `id?` | Send a user message. `id` is echoed back in ack/error |
+
+---
+
 ## Pagination
 
 List methods that are paginated return a `PaginatedResponse<T>`:

package/chat-client.d.ts

@@ -0,0 +1,106 @@
+/**
+ * HappyRobotChatClient — lightweight browser-side client for chat sessions.
+ *
+ * Initialized with a scoped client token (created server-side via
+ * `client.chat.createToken()`). Does NOT require an API key.
+ *
+ * @example
+ * ```ts
+ * import { HappyRobotChatClient } from "@happyrobot-ai/sdk";
+ *
+ * // Token comes from your server
+ * const chat = new HappyRobotChatClient({ token });
+ *
+ * const { session_id } = await chat.createSession();
+ *
+ * chat.connect(session_id, {
+ *   onResponseStart: () => { },
+ *   onResponseChunk: (content) => { },
+ *   onResponseEnd: (content) => { },
+ *   onSessionClosed: (event) => { },
+ * });
+ *
+ * await chat.sendMessage(session_id, { content: "Hello!" });
+ * ```
+ */
+import type { ChatClientConfig, CreateChatSessionResponse, SendChatMessageBody, SendChatMessageResponse, ChatHistoryResponse, PresignedUploadQuery, PresignedUploadResponse, CompleteUploadBody, CompleteUploadResponse, ChatWsSessionClosedEvent, ChatWsMessageAckEvent } from "./types/chat.types";
+export interface ChatConnectionHandlers {
+    /** AI started generating a response. */
+    onResponseStart?: () => void;
+    /** Partial response text chunk. */
+    onResponseChunk?: (content: string) => void;
+    /** Complete response text. */
+    onResponseEnd?: (content: string) => void;
+    /** Session was closed by the server. */
+    onSessionClosed?: (event: ChatWsSessionClosedEvent) => void;
+    /** Connection established. */
+    onConnected?: (sessionId: string) => void;
+    /** Token expired — reconnect with a fresh token to continue. */
+    onTokenExpired?: () => void;
+    /** WebSocket error. */
+    onError?: (error: Event) => void;
+    /** WebSocket closed. */
+    onClose?: (event: {
+        code: number;
+        reason: string;
+    }) => void;
+}
+export interface ChatConnection {
+    /** Close the WebSocket connection only (no server-side cleanup). */
+    close(): void;
+    /**
+     * End the session on the server (stops the AI agent) and close the WebSocket.
+     * Use this when the user is done with the conversation.
+     */
+    endSession(): Promise<void>;
+    /** Send a message through the WebSocket. Returns the ack from the server. */
+    sendMessage(body: SendChatMessageBody): Promise<ChatWsMessageAckEvent>;
+    /** The underlying WebSocket instance. */
+    readonly ws: WebSocket;
+}
+export declare class HappyRobotChatClient {
+    private readonly token;
+    private readonly baseUrl;
+    private readonly fetchFn;
+    constructor(config: ChatClientConfig);
+    /** Create a new chat session. */
+    createSession(): Promise<CreateChatSessionResponse>;
+    /** Send a user message to a chat session. */
+    sendMessage(sessionId: string, body: SendChatMessageBody): Promise<SendChatMessageResponse>;
+    /** Get message history for a chat session. */
+    getHistory(sessionId: string): Promise<ChatHistoryResponse>;
+    /**
+     * Get a presigned S3 URL for file upload.
+     *
+     * Upload flow:
+     * 1. `getPresignedUpload()` — get the upload URL
+     * 2. `PUT` the file directly to `upload_url`
+     * 3. `completeUpload()` — register the artifact
+     * 4. Include the artifact in `sendMessage()` via the `artifacts` array
+     */
+    getPresignedUpload(query: PresignedUploadQuery): Promise<PresignedUploadResponse>;
+    /** Register an uploaded artifact after direct S3 upload. */
+    completeUpload(body: CompleteUploadBody): Promise<CompleteUploadResponse>;
+    /**
+     * Upload a file and return the artifact metadata ready for `sendMessage()`.
+     *
+     * Convenience method that combines `getPresignedUpload()`, S3 upload, and
+     * `completeUpload()` into a single call.
+     */
+    uploadFile(file: Blob, filename: string, mimeType: string): Promise<{
+        media_id: string;
+        mime_type: string;
+        filename: string;
+        size_bytes: number;
+    }>;
+    /**
+     * Connect a bidirectional WebSocket for sending messages and receiving
+     * real-time AI response streaming.
+     *
+     * Returns a `ChatConnection` with `sendMessage()` and `close()` methods.
+     * Pass event handlers to react to streaming chunks, completed responses,
+     * and session lifecycle events.
+     */
+    connect(sessionId: string, handlers?: ChatConnectionHandlers): ChatConnection;
+    private request;
+}

package/chat-client.js

@@ -0,0 +1,251 @@
+"use strict";
+/**
+ * HappyRobotChatClient — lightweight browser-side client for chat sessions.
+ *
+ * Initialized with a scoped client token (created server-side via
+ * `client.chat.createToken()`). Does NOT require an API key.
+ *
+ * @example
+ * ```ts
+ * import { HappyRobotChatClient } from "@happyrobot-ai/sdk";
+ *
+ * // Token comes from your server
+ * const chat = new HappyRobotChatClient({ token });
+ *
+ * const { session_id } = await chat.createSession();
+ *
+ * chat.connect(session_id, {
+ *   onResponseStart: () => { },
+ *   onResponseChunk: (content) => { },
+ *   onResponseEnd: (content) => { },
+ *   onSessionClosed: (event) => { },
+ * });
+ *
+ * await chat.sendMessage(session_id, { content: "Hello!" });
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HappyRobotChatClient = void 0;
+const DEFAULT_BASE_URL = "https://platform.happyrobot.ai/api/v2";
+class HappyRobotChatClient {
+    token;
+    baseUrl;
+    fetchFn;
+    constructor(config) {
+        if (!config.token) {
+            throw new Error("token is required");
+        }
+        this.token = config.token;
+        const customBaseUrl = config.baseUrl;
+        const isTesting = typeof process !== "undefined" && process.env?.HR_TESTING === "true";
+        if (customBaseUrl && !isTesting) {
+            throw new Error("baseUrl can not be overridden");
+        }
+        this.baseUrl = (customBaseUrl ?? DEFAULT_BASE_URL).replace(/\/$/, "");
+        this.fetchFn = config.fetch ?? globalThis.fetch.bind(globalThis);
+    }
+    /** Create a new chat session. */
+    async createSession() {
+        return this.request("POST", "/chat/sessions");
+    }
+    /** Send a user message to a chat session. */
+    async sendMessage(sessionId, body) {
+        return this.request("POST", `/chat/sessions/${enc(sessionId)}/messages`, body);
+    }
+    /** Get message history for a chat session. */
+    async getHistory(sessionId) {
+        return this.request("GET", `/chat/sessions/${enc(sessionId)}/history`);
+    }
+    /**
+     * Get a presigned S3 URL for file upload.
+     *
+     * Upload flow:
+     * 1. `getPresignedUpload()` — get the upload URL
+     * 2. `PUT` the file directly to `upload_url`
+     * 3. `completeUpload()` — register the artifact
+     * 4. Include the artifact in `sendMessage()` via the `artifacts` array
+     */
+    async getPresignedUpload(query) {
+        const params = new URLSearchParams({
+            filename: query.filename,
+            mime_type: query.mime_type,
+        });
+        return this.request("GET", `/chat/upload/presigned?${params.toString()}`);
+    }
+    /** Register an uploaded artifact after direct S3 upload. */
+    async completeUpload(body) {
+        return this.request("POST", "/chat/upload/complete", body);
+    }
+    /**
+     * Upload a file and return the artifact metadata ready for `sendMessage()`.
+     *
+     * Convenience method that combines `getPresignedUpload()`, S3 upload, and
+     * `completeUpload()` into a single call.
+     */
+    async uploadFile(file, filename, mimeType) {
+        const upload = await this.getPresignedUpload({
+            filename,
+            mime_type: mimeType,
+        });
+        await this.fetchFn(upload.upload_url, {
+            method: "PUT",
+            body: file,
+            headers: { "Content-Type": mimeType },
+        });
+        const completed = await this.completeUpload({
+            artifact_id: upload.artifact_id,
+            s3_uri: upload.s3_uri,
+            filename,
+            mime_type: mimeType,
+            size_bytes: file.size,
+        });
+        return {
+            media_id: completed.artifact_id,
+            mime_type: mimeType,
+            filename,
+            size_bytes: file.size,
+        };
+    }
+    /**
+     * Connect a bidirectional WebSocket for sending messages and receiving
+     * real-time AI response streaming.
+     *
+     * Returns a `ChatConnection` with `sendMessage()` and `close()` methods.
+     * Pass event handlers to react to streaming chunks, completed responses,
+     * and session lifecycle events.
+     */
+    connect(sessionId, handlers = {}) {
+        const wsBase = this.baseUrl
+            .replace(/^http:/, "ws:")
+            .replace(/^https:/, "wss:");
+        const url = `${wsBase}/chat/sessions/${enc(sessionId)}/ws?token=${enc(this.token)}`;
+        const ws = new WebSocket(url);
+        // Pending message-ack/message-error callbacks keyed by client-generated id.
+        const pending = new Map();
+        ws.onmessage = (event) => {
+            try {
+                const data = JSON.parse(event.data);
+                switch (data.type) {
+                    case "connected":
+                        handlers.onConnected?.(data.session_id);
+                        break;
+                    case "response-start":
+                        handlers.onResponseStart?.();
+                        break;
+                    case "response-chunk":
+                        handlers.onResponseChunk?.(data.content);
+                        break;
+                    case "response-end":
+                        handlers.onResponseEnd?.(data.content);
+                        break;
+                    case "session-closed":
+                        handlers.onSessionClosed?.(data);
+                        break;
+                    case "token-expired":
+                        handlers.onTokenExpired?.();
+                        break;
+                    case "message-ack": {
+                        const id = data.id;
+                        if (id && pending.has(id)) {
+                            pending.get(id).resolve(data);
+                            pending.delete(id);
+                        }
+                        break;
+                    }
+                    case "message-error": {
+                        const id = data.id;
+                        if (id && pending.has(id)) {
+                            pending.get(id).reject(new Error(data.error));
+                            pending.delete(id);
+                        }
+                        break;
+                    }
+                    case "heartbeat":
+                        break;
+                }
+            }
+            catch {
+                // Ignore malformed messages
+            }
+        };
+        ws.onerror = (event) => {
+            handlers.onError?.(event);
+        };
+        ws.onclose = (event) => {
+            // Reject all pending messages on close
+            for (const [, { reject }] of pending) {
+                reject(new Error("WebSocket closed"));
+            }
+            pending.clear();
+            handlers.onClose?.(event);
+        };
+        const sendMessage = (body) => {
+            return new Promise((resolve, reject) => {
+                if (ws.readyState !== WebSocket.OPEN) {
+                    reject(new Error("WebSocket is not open"));
+                    return;
+                }
+                const id = crypto.randomUUID();
+                pending.set(id, { resolve, reject });
+                ws.send(JSON.stringify({
+                    type: "message",
+                    id,
+                    content: body.content,
+                    ...(body.artifacts && body.artifacts.length > 0
+                        ? { artifacts: body.artifacts }
+                        : {}),
+                }));
+            });
+        };
+        const endSession = async () => {
+            await this.request("POST", `/chat/sessions/${enc(sessionId)}/close`);
+            ws.close();
+        };
+        return {
+            close: () => ws.close(),
+            endSession,
+            sendMessage,
+            get ws() {
+                return ws;
+            },
+        };
+    }
+    // ── Internal ──
+    async request(method, path, body) {
+        const url = `${this.baseUrl}${path}`;
+        const headers = {
+            Authorization: `Bearer ${this.token}`,
+            Accept: "application/json",
+        };
+        if (body !== undefined) {
+            headers["Content-Type"] = "application/json";
+        }
+        const response = await this.fetchFn(url, {
+            method,
+            headers,
+            body: body !== undefined ? JSON.stringify(body) : undefined,
+        });
+        if (!response.ok) {
+            const errorBody = await response.text().catch(() => "");
+            let parsed = {};
+            try {
+                parsed = JSON.parse(errorBody);
+            }
+            catch {
+                // ignore
+            }
+            throw new Error(parsed.error ||
+                parsed.message ||
+                `Request failed with status ${response.status}`);
+        }
+        const text = await response.text();
+        if (!text)
+            return undefined;
+        return JSON.parse(text);
+    }
+}
+exports.HappyRobotChatClient = HappyRobotChatClient;
+function enc(s) {
+    return encodeURIComponent(s);
+}
+//# sourceMappingURL=chat-client.js.map

package/chat-client.mjs

@@ -0,0 +1,3 @@
+// ESM wrapper — re-exports CJS module
+export { default } from "./chat-client.js";
+export * from "./chat-client.js";

package/client.d.ts

@@ -32,6 +32,8 @@ import { NorthstarsResource } from "./resources/northstars";
 import { CustomEvalsResource } from "./resources/custom-evals";
 import { IssuesResource } from "./resources/issues";
 import { AuditRemarksResource } from "./resources/audit-remarks";
+import { ChatResource } from "./resources/chat";
+import { ArtifactsResource } from "./resources/artifacts";
 export declare class HappyRobotClient {
     private readonly http;
     /** Workflow CRUD, publishing, runs, and templates. */
@@ -78,5 +80,9 @@ export declare class HappyRobotClient {
     readonly issues: IssuesResource;
     /** Audit remark feedback management. */
     readonly auditRemarks: AuditRemarksResource;
+    /** Chat session management and messaging. */
+    readonly chat: ChatResource;
+    /** Artifact URL resolution. */
+    readonly artifacts: ArtifactsResource;
     constructor(config: ClientConfig);
 }

package/client.js

@@ -35,6 +35,8 @@ const northstars_1 = require("./resources/northstars");
 const custom_evals_1 = require("./resources/custom-evals");
 const issues_1 = require("./resources/issues");
 const audit_remarks_1 = require("./resources/audit-remarks");
+const chat_1 = require("./resources/chat");
+const artifacts_1 = require("./resources/artifacts");
 class HappyRobotClient {
     http;
     /** Workflow CRUD, publishing, runs, and templates. */
@@ -81,6 +83,10 @@ class HappyRobotClient {
     issues;
     /** Audit remark feedback management. */
     auditRemarks;
+    /** Chat session management and messaging. */
+    chat;
+    /** Artifact URL resolution. */
+    artifacts;
     constructor(config) {
         this.http = new http_1.HttpClient(config);
         this.workflows = new workflows_1.WorkflowsResource(this.http);
@@ -105,6 +111,8 @@ class HappyRobotClient {
         this.customEvals = new custom_evals_1.CustomEvalsResource(this.http);
         this.issues = new issues_1.IssuesResource(this.http);
         this.auditRemarks = new audit_remarks_1.AuditRemarksResource(this.http);
+        this.chat = new chat_1.ChatResource(this.http);
+        this.artifacts = new artifacts_1.ArtifactsResource(this.http);
     }
 }
 exports.HappyRobotClient = HappyRobotClient;

package/core/http.js

@@ -22,8 +22,9 @@ class HttpClient {
         }
         this.apiKey = config.apiKey;
         const customBaseUrl = config.baseUrl;
-        if (customBaseUrl && !config.apiKey.startsWith("sk_test_")) {
-            throw new Error("baseUrl can only be overridden with a test API key (sk_test_...)");
+        const isTesting = typeof process !== "undefined" && process.env?.HR_TESTING === "true";
+        if (customBaseUrl && !isTesting) {
+            throw new Error("baseUrl can not be overridden");
         }
         this.baseUrl = (customBaseUrl ?? DEFAULT_BASE_URL).replace(/\/$/, "");
         this.timeout = config.timeout ?? DEFAULT_TIMEOUT;

package/index.d.ts

@@ -22,6 +22,8 @@
  * ```
  */
 export { HappyRobotClient } from "./client";
+export { HappyRobotChatClient } from "./chat-client";
+export type { ChatConnectionHandlers, ChatConnection } from "./chat-client";
 export type { ClientConfig, RequestConfig, PaginatedResponse, PaginationMetadata, PaginationQuery } from "./core/types";
 export { HappyRobotError, ApiError, AuthenticationError, NotFoundError, ValidationError, RateLimitError, TimeoutError, NetworkError, } from "./core/errors";
 export type { ApiErrorBody } from "./core/errors";
@@ -51,6 +53,8 @@ export { NorthstarsResource } from "./resources/northstars";
 export { CustomEvalsResource } from "./resources/custom-evals";
 export { IssuesResource } from "./resources/issues";
 export { AuditRemarksResource } from "./resources/audit-remarks";
+export { ChatResource } from "./resources/chat";
+export { ArtifactsResource } from "./resources/artifacts";
 export type * from "./types/workflows.types";
 export type * from "./types/versions.types";
 export type * from "./types/nodes.types";
@@ -71,3 +75,5 @@ export type * from "./types/northstars.types";
 export type * from "./types/custom-evals.types";
 export type * from "./types/issues.types";
 export type * from "./types/audit-remarks.types";
+export type * from "./types/chat.types";
+export type * from "./types/artifacts.types";

package/index.js

@@ -23,10 +23,12 @@
  * ```
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AuditRemarksResource = exports.IssuesResource = exports.CustomEvalsResource = exports.NorthstarsResource = exports.AdversarialTestsResource = exports.AdversarialSuitesResource = exports.ApiKeyResource = exports.BillingResource = exports.MCPResource = exports.WorkflowFoldersResource = exports.KnowledgeBasesResource = exports.ContactsResource = exports.IntegrationsResource = exports.SipTrunksResource = exports.PhoneNumbersResource = exports.VariablesResource = exports.MessagesResource = exports.SessionsResource = exports.RunsResource = exports.NodesResource = exports.VersionsResource = exports.WorkflowsResource = exports.iterateSSE = exports.paginate = exports.NetworkError = exports.TimeoutError = exports.RateLimitError = exports.ValidationError = exports.NotFoundError = exports.AuthenticationError = exports.ApiError = exports.HappyRobotError = exports.HappyRobotClient = void 0;
-// ── Client ──
+exports.ArtifactsResource = exports.ChatResource = exports.AuditRemarksResource = exports.IssuesResource = exports.CustomEvalsResource = exports.NorthstarsResource = exports.AdversarialTestsResource = exports.AdversarialSuitesResource = exports.ApiKeyResource = exports.BillingResource = exports.MCPResource = exports.WorkflowFoldersResource = exports.KnowledgeBasesResource = exports.ContactsResource = exports.IntegrationsResource = exports.SipTrunksResource = exports.PhoneNumbersResource = exports.VariablesResource = exports.MessagesResource = exports.SessionsResource = exports.RunsResource = exports.NodesResource = exports.VersionsResource = exports.WorkflowsResource = exports.iterateSSE = exports.paginate = exports.NetworkError = exports.TimeoutError = exports.RateLimitError = exports.ValidationError = exports.NotFoundError = exports.AuthenticationError = exports.ApiError = exports.HappyRobotError = exports.HappyRobotChatClient = exports.HappyRobotClient = void 0;
+// ── Clients ──
 var client_1 = require("./client");
 Object.defineProperty(exports, "HappyRobotClient", { enumerable: true, get: function () { return client_1.HappyRobotClient; } });
+var chat_client_1 = require("./chat-client");
+Object.defineProperty(exports, "HappyRobotChatClient", { enumerable: true, get: function () { return chat_client_1.HappyRobotChatClient; } });
 var errors_1 = require("./core/errors");
 Object.defineProperty(exports, "HappyRobotError", { enumerable: true, get: function () { return errors_1.HappyRobotError; } });
 Object.defineProperty(exports, "ApiError", { enumerable: true, get: function () { return errors_1.ApiError; } });
@@ -85,4 +87,8 @@ var issues_1 = require("./resources/issues");
 Object.defineProperty(exports, "IssuesResource", { enumerable: true, get: function () { return issues_1.IssuesResource; } });
 var audit_remarks_1 = require("./resources/audit-remarks");
 Object.defineProperty(exports, "AuditRemarksResource", { enumerable: true, get: function () { return audit_remarks_1.AuditRemarksResource; } });
+var chat_1 = require("./resources/chat");
+Object.defineProperty(exports, "ChatResource", { enumerable: true, get: function () { return chat_1.ChatResource; } });
+var artifacts_1 = require("./resources/artifacts");
+Object.defineProperty(exports, "ArtifactsResource", { enumerable: true, get: function () { return artifacts_1.ArtifactsResource; } });
 //# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@happyrobot-ai/sdk",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "TypeScript SDK for the HappyRobot Public API",
   "main": "./index.js",
   "module": "./index.mjs",
@@ -37,7 +37,8 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/happyrobot-ai/app-v2"
+    "url": "git+https://github.com/happyrobot-ai/app-v2.git",
+    "directory": "packages/public_api"
   },
   "dependencies": {}
 }

package/resources/artifacts.d.ts

@@ -0,0 +1,7 @@
+import type { HttpClient } from "../core/http";
+import type { ResolveArtifactsBody, ResolveArtifactsResponse } from "../types/artifacts.types";
+export declare class ArtifactsResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    resolve(body: ResolveArtifactsBody): Promise<ResolveArtifactsResponse>;
+}

package/resources/artifacts.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArtifactsResource = void 0;
+class ArtifactsResource {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    async resolve(body) {
+        return this.http.request({
+            method: "POST",
+            path: "/artifacts/resolve",
+            body,
+        });
+    }
+}
+exports.ArtifactsResource = ArtifactsResource;
+//# sourceMappingURL=artifacts.js.map

package/resources/artifacts.mjs

@@ -0,0 +1,3 @@
+// ESM wrapper — re-exports CJS module
+export { default } from "./artifacts.js";
+export * from "./artifacts.js";

package/resources/chat.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Chat resource — client.chat.*
+ *
+ * Server-side only. Creates scoped client tokens that are passed to the
+ * browser-side `HappyRobotChatClient`.
+ *
+ * @example
+ * ```ts
+ * const client = new HappyRobotClient({ apiKey: "sk_live_..." });
+ * const { token } = await client.chat.createToken({ workflow_id: "..." });
+ * // Pass `token` to the browser → new HappyRobotChatClient({ token })
+ * ```
+ */
+import type { HttpClient } from "../core/http";
+import type { CreateChatTokenBody, CreateChatTokenResponse } from "../types/chat.types";
+export declare class ChatResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * Create a scoped client token for browser-side chat operations.
+     *
+     * Call this from your server, then pass the returned `token` to the browser
+     * where it can be used to initialize `HappyRobotChatClient`.
+     */
+    createToken(body: CreateChatTokenBody): Promise<CreateChatTokenResponse>;
+}

package/resources/chat.js

@@ -0,0 +1,37 @@
+"use strict";
+/**
+ * Chat resource — client.chat.*
+ *
+ * Server-side only. Creates scoped client tokens that are passed to the
+ * browser-side `HappyRobotChatClient`.
+ *
+ * @example
+ * ```ts
+ * const client = new HappyRobotClient({ apiKey: "sk_live_..." });
+ * const { token } = await client.chat.createToken({ workflow_id: "..." });
+ * // Pass `token` to the browser → new HappyRobotChatClient({ token })
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChatResource = void 0;
+class ChatResource {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    /**
+     * Create a scoped client token for browser-side chat operations.
+     *
+     * Call this from your server, then pass the returned `token` to the browser
+     * where it can be used to initialize `HappyRobotChatClient`.
+     */
+    async createToken(body) {
+        return this.http.request({
+            method: "POST",
+            path: "/chat/tokens",
+            body,
+        });
+    }
+}
+exports.ChatResource = ChatResource;
+//# sourceMappingURL=chat.js.map

package/resources/chat.mjs

@@ -0,0 +1,3 @@
+// ESM wrapper — re-exports CJS module
+export { default } from "./chat.js";
+export * from "./chat.js";