@thaliq/sdk 1.0.0

package/README.md

@@ -0,0 +1,224 @@
+# @thaliq/sdk
+
+Headless, type-safe, provider-agnostic SDK for building applications with [Thaliq](https://thaliq.com) AI agents.
+
+- **Streaming-first** — `AsyncIterable<StreamEvent>` as primary primitive
+- **Zero dependencies** — Only native runtime APIs (`fetch`, `ReadableStream`)
+- **Provider-agnostic** — Swap backends via the `Provider` interface
+- **Human-in-the-Loop** — Built-in HITL action support (consent, confirm, select, form)
+- **Automatic retry** — Exponential backoff on server/network errors
+
+## Installation
+
+```bash
+npm install @thaliq/sdk
+```
+
+## Quick Start
+
+```typescript
+import { Thaliq } from '@thaliq/sdk';
+
+const thaliq = new Thaliq({ apiKey: 'tq_live_xxx' });
+
+// Non-streaming
+const response = await thaliq.agent.chat('Hello!');
+console.log(response.message);
+
+// Streaming
+const stream = thaliq.agent.stream('Analyze Q4 sales');
+for await (const event of stream) {
+  if (event.type === 'content.delta') {
+    process.stdout.write(event.delta);
+  }
+}
+```
+
+## Streaming
+
+Every stream event has a `type` field for type narrowing:
+
+```typescript
+const stream = thaliq.agent.stream('Hello');
+
+for await (const event of stream) {
+  switch (event.type) {
+    case 'meta':
+      console.log('Conversation:', event.conversationId);
+      break;
+    case 'status':
+      console.log('Status:', event.text);
+      break;
+    case 'content.delta':
+      process.stdout.write(event.delta);
+      break;
+    case 'tool.start':
+      console.log(`Running tool: ${event.tool}`);
+      break;
+    case 'tool.end':
+      console.log(`Tool ${event.tool}: ${event.success ? 'ok' : 'failed'}`);
+      break;
+    case 'response.completed':
+      console.log('\nDone. Tokens:', event.metadata.completionTokens);
+      break;
+    case 'error':
+      console.error('Error:', event.message);
+      break;
+  }
+}
+```
+
+### Convenience methods
+
+```typescript
+// Get just the text
+const text = await thaliq.agent.stream('Summarize this').text();
+
+// Get the full response (like chat, but streamed)
+const response = await thaliq.agent.stream('Summarize this').finalResponse();
+```
+
+## User Identity
+
+For authenticated B2B scenarios, identify the user before sending messages:
+
+```typescript
+thaliq.identify({
+  userId: 'usr_123',
+  email: 'user@company.com',
+  token: 'eyJ...', // JWT passthrough for MCP servers
+  mcpTokens: { 'my-mcp-server': 'server-specific-token' },
+});
+
+// Clear on logout
+thaliq.reset();
+```
+
+## Human-in-the-Loop (HITL)
+
+When the agent requires user approval before executing a tool:
+
+```typescript
+import { ActionResponseBuilder } from '@thaliq/sdk';
+
+const stream = thaliq.agent.stream('Transfer $500 to Alice');
+for await (const event of stream) {
+  if (event.type === 'content.delta') process.stdout.write(event.delta);
+}
+
+if (stream.pendingAction) {
+  // User approved — resume the stream
+  const resumed = thaliq.agent.respondToAction({
+    conversationId: stream.conversationId!,
+    originalMessage: 'Transfer $500 to Alice',
+    actionResponse: ActionResponseBuilder.accept(stream.pendingAction.instructionId),
+  });
+
+  for await (const event of resumed) {
+    if (event.type === 'content.delta') process.stdout.write(event.delta);
+  }
+}
+```
+
+Action response helpers:
+
+```typescript
+ActionResponseBuilder.accept(instructionId);                // consent/confirm
+ActionResponseBuilder.reject(instructionId);                // reject
+ActionResponseBuilder.select(instructionId, 'option_a');    // select
+ActionResponseBuilder.submitForm(instructionId, { amount: '500' }); // form
+```
+
+## Conversations
+
+Conversations are auto-tracked across streams:
+
+```typescript
+const stream = thaliq.agent.stream('Hello');
+for await (const event of stream) { /* ... */ }
+
+// Continue the conversation
+const followUp = thaliq.agent.stream('Tell me more', {
+  conversationId: thaliq.conversations.active!.id,
+});
+```
+
+## Configuration
+
+```typescript
+const thaliq = new Thaliq({
+  apiKey: 'tq_live_xxx',           // Required
+  baseUrl: 'https://api.thaliq.com', // Default
+  integrationType: 'sdk',           // 'sdk' | 'widget'
+  timeout: 30000,                   // Request timeout (ms)
+  maxRetries: 2,                    // Automatic retries
+  retry: {
+    baseDelay: 500,                 // Initial retry delay
+    maxDelay: 10000,                // Max retry delay
+  },
+  logLevel: 'warn',                 // 'debug' | 'info' | 'warn' | 'error' | 'silent'
+  defaultHeaders: {                 // Custom headers on every request
+    'x-tenant-id': 'abc',
+  },
+});
+```
+
+## Events
+
+```typescript
+thaliq.on('error', (err) => console.error(err.code, err.message));
+thaliq.on('retry', (attempt, err, delayMs) => console.warn(`Retry #${attempt}`));
+thaliq.on('stream.start', (convId) => { /* ... */ });
+thaliq.on('stream.end', (convId) => { /* ... */ });
+thaliq.on('identify', (userId) => { /* ... */ });
+thaliq.on('reset', () => { /* ... */ });
+```
+
+## Error Handling
+
+All SDK errors extend `ThaliqError` with a `code` property:
+
+```typescript
+import { ThaliqError, AuthError, RateLimitError } from '@thaliq/sdk';
+
+try {
+  await thaliq.agent.chat('Hello');
+} catch (err) {
+  if (err instanceof RateLimitError) {
+    console.log(`Rate limited. Retry after ${err.retryAfter}s`);
+  } else if (err instanceof AuthError) {
+    console.log('Invalid API key');
+  } else if (err instanceof ThaliqError) {
+    console.log(err.code, err.message);
+  }
+}
+```
+
+| Error Class | Code | HTTP Status |
+|-------------|------|-------------|
+| `AuthError` | `AUTH_ERROR` | 401, 403 |
+| `RateLimitError` | `RATE_LIMIT` | 429 |
+| `ValidationError` | `VALIDATION_ERROR` | 400 |
+| `ServiceError` | `SERVICE_ERROR` | 503 |
+| `StreamError` | `STREAM_ERROR` | — |
+| `TimeoutError` | `TIMEOUT_ERROR` | — |
+| `ConnectionError` | `CONNECTION_ERROR` | — |
+
+## Compatibility
+
+| Runtime | Minimum |
+|---------|---------|
+| Node.js | 18+ (native `fetch`) |
+| Browsers | Chrome 89+, Firefox 89+, Safari 15+ |
+| Deno | 1.28+ |
+| Bun | 1.0+ |
+
+## Documentation
+
+- [Full SDK Documentation](https://docs.thaliq.com/sdk)
+- [SDK Protocol Specification](https://docs.thaliq.com/sdk/protocol)
+- [Integration Guide](https://docs.thaliq.com/integration)
+
+## License
+
+MIT

package/__test-utils__/helpers.d.ts

@@ -0,0 +1,20 @@
+import { Logger } from '../types/config';
+import { Provider, ProviderRequest } from '../types/provider';
+import { ChatResponse } from '../types/responses';
+import { StreamEvent } from '../types/events';
+/** Create a mock logger that captures calls */
+export declare function createMockLogger(): Logger & {
+    calls: Record<string, unknown[][]>;
+};
+/** Encode SSE events into a ReadableStream<Uint8Array> */
+export declare function createSSEStream(events: Array<{
+    event: string;
+    data: string;
+}>): ReadableStream<Uint8Array>;
+/** Create a mock provider for testing */
+export declare function createMockProvider(overrides?: {
+    chat?: (request: ProviderRequest) => Promise<ChatResponse>;
+    stream?: (request: ProviderRequest) => AsyncIterable<StreamEvent>;
+}): Provider;
+/** Sleep for a given number of milliseconds */
+export declare function delay(ms: number): Promise<void>;

package/agent/agent-client.d.ts

@@ -0,0 +1,45 @@
+import { Provider } from '../types/provider';
+import { ChatOptions, StreamOptions, AgentStream, RespondToActionOptions } from '../types/agent';
+import { ChatResponse } from '../types/responses';
+import { UserIdentity } from '../types/identity';
+import { ResolvedConfig, SDKEventMap } from '../types/config';
+import { TypedEventEmitter } from '../utils/event-emitter';
+import { ConversationManager } from './conversation-manager';
+export declare class AgentClient {
+    private readonly config;
+    private readonly provider;
+    private readonly getIdentity;
+    private readonly emitter;
+    private readonly conversationManager;
+    constructor(config: ResolvedConfig, provider: Provider, getIdentity: () => UserIdentity | null, emitter: TypedEventEmitter<SDKEventMap>, conversationManager: ConversationManager);
+    /** Send a message and wait for the complete response (with automatic retry) */
+    chat(message: string, options?: ChatOptions): Promise<ChatResponse>;
+    /** Send a message with streaming — returns an AgentStream */
+    stream(message: string, options?: StreamOptions): AgentStream;
+    /**
+     * Respond to a pending HITL action and resume the conversation.
+     *
+     * This is a convenience method that creates a new stream with the
+     * action response, continuing the conversation where it left off.
+     *
+     * @example
+     * ```typescript
+     * const stream = thaliq.agent.stream('Transfer $500');
+     * for await (const event of stream) { ... }
+     *
+     * if (stream.pendingAction) {
+     *   const resumed = thaliq.agent.respondToAction({
+     *     conversationId: stream.conversationId!,
+     *     originalMessage: 'Transfer $500',
+     *     actionResponse: ActionResponseBuilder.accept(stream.pendingAction.instructionId),
+     *   });
+     *   for await (const event of resumed) { ... }
+     * }
+     * ```
+     */
+    respondToAction(options: RespondToActionOptions): AgentStream;
+    /** Build the ProviderRequest from message + options + identity */
+    private buildRequest;
+    /** Resolve all headers from config + identity */
+    private resolveHeaders;
+}

package/agent/agent-stream.d.ts

@@ -0,0 +1,22 @@
+import { AgentStream as IAgentStream, StreamStatus } from '../types/agent';
+import { StreamEvent } from '../types/events';
+import { ChatResponse } from '../types/responses';
+import { PendingAction } from '../types/actions';
+export declare class AgentStreamImpl implements IAgentStream {
+    private _conversationId;
+    private _status;
+    private _pendingAction;
+    private readonly _source;
+    private readonly _abortController;
+    private readonly _onEvent?;
+    private readonly _onComplete?;
+    private _consumed;
+    constructor(source: AsyncIterable<StreamEvent>, abortController: AbortController, onEvent?: (event: StreamEvent) => void, onComplete?: (conversationId: string | null, status: StreamStatus) => void);
+    get conversationId(): string | null;
+    get status(): StreamStatus;
+    get pendingAction(): PendingAction | null;
+    abort(): void;
+    [Symbol.asyncIterator](): AsyncIterator<StreamEvent>;
+    finalResponse(): Promise<ChatResponse>;
+    text(): Promise<string>;
+}

package/agent/conversation-manager.d.ts

@@ -0,0 +1,19 @@
+import { ConversationRef } from '../types/conversations';
+export declare class ConversationManager {
+    private _active;
+    private readonly _history;
+    /** Create a new conversation reference */
+    create(): ConversationRef;
+    /** Get the most recently active conversation */
+    get active(): ConversationRef | null;
+    /** Get all known conversation references (in-memory only) */
+    get history(): readonly ConversationRef[];
+    /**
+     * Set the active conversation by ID (called internally after stream completes).
+     * If the ID matches an existing ref, that ref becomes active.
+     * Otherwise a new ref is created.
+     */
+    setActive(conversationId: string): void;
+    /** Clear all state */
+    clear(): void;
+}

package/agent/index.d.ts

@@ -0,0 +1,3 @@
+export { AgentClient } from './agent-client';
+export { AgentStreamImpl } from './agent-stream';
+export { ConversationManager } from './conversation-manager';

package/client.d.ts

@@ -0,0 +1,25 @@
+import { ThaliqConfig, SDKEventMap } from './types/config';
+import { UserIdentity } from './types/identity';
+import { AgentClient } from './agent/agent-client';
+import { ConversationManager } from './agent/conversation-manager';
+export declare class Thaliq {
+    private readonly config;
+    private readonly provider;
+    private readonly emitter;
+    private identity;
+    /** Agent client — use `thaliq.agent.chat()` and `thaliq.agent.stream()` */
+    readonly agent: AgentClient;
+    /** Conversations manager — create, track, and list conversations */
+    readonly conversations: ConversationManager;
+    constructor(userConfig: ThaliqConfig);
+    /** Register an event listener */
+    on<K extends keyof SDKEventMap>(event: K, listener: SDKEventMap[K]): this;
+    /** Register a one-time event listener */
+    once<K extends keyof SDKEventMap>(event: K, listener: SDKEventMap[K]): this;
+    /** Remove an event listener */
+    off<K extends keyof SDKEventMap>(event: K, listener: SDKEventMap[K]): this;
+    /** Set the user identity for subsequent requests */
+    identify(user: UserIdentity): void;
+    /** Clear user identity and local state */
+    reset(): void;
+}

package/index.d.ts

@@ -0,0 +1,47 @@
+/**
+ * @thaliq/sdk — Agentic SDK for Thaliq Platform
+ *
+ * Headless, type-safe, provider-agnostic SDK for building
+ * applications with Thaliq AI agents.
+ *
+ * @example
+ * ```typescript
+ * import { Thaliq } from '@thaliq/sdk';
+ *
+ * const thaliq = new Thaliq({ apiKey: 'tq_live_xxx' });
+ *
+ * // Events
+ * thaliq.on('error', (err) => console.error(err));
+ * thaliq.on('retry', (attempt, err, delay) => console.warn(`Retry #${attempt}`));
+ *
+ * // Stream with auto-tracking
+ * const stream = thaliq.agent.stream('Hello!');
+ * for await (const event of stream) {
+ *   if (event.type === 'content.delta') {
+ *     process.stdout.write(event.delta);
+ *   }
+ * }
+ *
+ * console.log(thaliq.conversations.active);
+ * ```
+ *
+ * @packageDocumentation
+ */
+export { Thaliq } from './client';
+export { ThaliqNativeProvider } from './providers/thaliq-native';
+export type { ThaliqNativeProviderConfig } from './providers/thaliq-native';
+export { ConversationManager } from './agent/conversation-manager';
+export type { ThaliqConfig, ResolvedConfig, RetryConfig, ResolvedRetryConfig, SDKEventMap, Logger, LogLevel, } from './types/config';
+export type { UserIdentity } from './types/identity';
+export type { AgentType, ChatOptions, StreamOptions, AgentStream, StreamStatus, RespondToActionOptions, } from './types/agent';
+export type { StreamEvent, MetaEvent, StatusEvent, ContentDeltaEvent, ToolStartEvent, ToolEndEvent, ActionEvent, ResponseCompletedEvent, ErrorEvent, KeepaliveEvent, } from './types/events';
+export type { ChatResponse, ResponseMetadata, Insight, InsightType, InsightSeverity, } from './types/responses';
+export type { ActionType, RejectBehavior, FieldType, ActionOption, ActionField, PendingAction, ActionResponse, } from './types/actions';
+export type { ConversationRef } from './types/conversations';
+export type { Provider, ProviderRequest, ResolvedHeaders, } from './types/provider';
+export { ActionResponseBuilder } from './utils/action-response-builder';
+export { TypedEventEmitter } from './utils/event-emitter';
+export { isRetryableError, calculateBackoff, withRetry } from './utils/retry';
+export type { RetryOptions } from './utils/retry';
+export { ThaliqError, AuthError, RateLimitError, ValidationError, ServiceError, StreamError, TimeoutError, ConnectionError, } from './types/errors';
+export type { ErrorCode } from './types/errors';

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@thaliq/sdk",
+  "version": "1.0.0",
+  "description": "Headless, type-safe, provider-agnostic SDK for Thaliq AI agents",
+  "type": "module",
+  "main": "./thaliq-sdk.cjs.js",
+  "module": "./thaliq-sdk.es.js",
+  "types": "./index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./thaliq-sdk.es.js",
+      "require": "./thaliq-sdk.cjs.js"
+    }
+  },
+  "sideEffects": false,
+  "license": "MIT",
+  "author": "Thaliq <hello@thaliq.com> (https://thaliq.com)",
+  "homepage": "https://docs.thaliq.com/sdk",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/thaliq/sdk"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "keywords": [
+    "thaliq",
+    "ai",
+    "agents",
+    "sdk",
+    "streaming",
+    "sse",
+    "llm",
+    "ai-agents",
+    "hitl",
+    "human-in-the-loop"
+  ]
+}

package/providers/thaliq-native/http-client.d.ts

@@ -0,0 +1,26 @@
+import { Logger } from '../../types/config';
+export interface HttpClientConfig {
+    baseUrl: string;
+    timeout: number;
+    logger: Logger;
+}
+export interface HttpRequestOptions {
+    method: 'GET' | 'POST';
+    path: string;
+    headers: Record<string, string | undefined>;
+    body?: unknown;
+    signal?: AbortSignal;
+    timeout: number;
+}
+export declare class HttpClient {
+    private readonly baseUrl;
+    private readonly defaultTimeout;
+    private readonly logger;
+    constructor(config: HttpClientConfig);
+    /** Execute a JSON request and return the parsed response */
+    json<T>(options: HttpRequestOptions): Promise<T>;
+    /** Execute a request and return the raw Response (for SSE streaming) */
+    stream(options: HttpRequestOptions): Promise<Response>;
+    /** Low-level fetch with timeout and error wrapping */
+    private rawFetch;
+}

package/providers/thaliq-native/index.d.ts

@@ -0,0 +1,2 @@
+export { ThaliqNativeProvider } from './thaliq-native.provider';
+export type { ThaliqNativeProviderConfig } from './thaliq-native.provider';

package/providers/thaliq-native/sse-parser.d.ts

@@ -0,0 +1,6 @@
+import { StreamEvent } from '../../types/events';
+/**
+ * Parse a ReadableStream into SSE events.
+ * Yields StreamEvent objects as they arrive.
+ */
+export declare function parseSSEStream(stream: ReadableStream<Uint8Array>): AsyncIterable<StreamEvent>;

package/providers/thaliq-native/thaliq-native.provider.d.ts

@@ -0,0 +1,19 @@
+import { Provider, ProviderRequest } from '../../types/provider';
+import { ChatResponse } from '../../types/responses';
+import { StreamEvent } from '../../types/events';
+import { Logger } from '../../types/config';
+export interface ThaliqNativeProviderConfig {
+    baseUrl: string;
+    timeout: number;
+    logger: Logger;
+}
+export declare class ThaliqNativeProvider implements Provider {
+    readonly name = "thaliq-native";
+    private readonly http;
+    private readonly logger;
+    constructor(config: ThaliqNativeProviderConfig);
+    /** POST /api/agent/chat — non-streaming */
+    chat(request: ProviderRequest): Promise<ChatResponse>;
+    /** GET /api/agent/stream — SSE streaming */
+    stream(request: ProviderRequest): AsyncIterable<StreamEvent>;
+}

package/thaliq-sdk.cjs.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});class t extends Error{constructor(t,e,s){super(t),this.name="ThaliqError",this.code=e,this.status=s}}class e extends t{constructor(t,e=401){super(t,"AUTH_ERROR",e),this.name="AuthError"}}class s extends t{constructor(t,e=60){super(t,"RATE_LIMIT",429),this.name="RateLimitError",this.retryAfter=e}}class n extends t{constructor(t){super(t,"VALIDATION_ERROR",400),this.name="ValidationError"}}class r extends t{constructor(t){super(t,"SERVICE_ERROR",503),this.name="ServiceError"}}class o extends t{constructor(t){super(t,"STREAM_ERROR"),this.name="StreamError"}}class i extends t{constructor(t="Request timed out"){super(t,"TIMEOUT_ERROR"),this.name="TimeoutError"}}class a extends t{constructor(t="Connection failed"){super(t,"CONNECTION_ERROR"),this.name="ConnectionError"}}function c(o,i,a){switch(o){case 400:return new n(i);case 401:case 403:return new e(i,o);case 429:{const t=a?.get("retry-after");return new s(i,t?parseInt(t,10):60)}case 503:return new r(i);default:return new t(i,"UNKNOWN_ERROR",o)}}class l{constructor(t,e,s,n){this._conversationId=null,this._status="streaming",this._pendingAction=null,this._consumed=!1,this._source=t,this._abortController=e,this._onEvent=s,this._onComplete=n}get conversationId(){return this._conversationId}get status(){return this._status}get pendingAction(){return this._pendingAction}abort(){this._status="aborted",this._abortController.abort()}async*[Symbol.asyncIterator](){if(this._consumed)throw new o("AgentStream can only be consumed once");this._consumed=!0;try{for await(const t of this._source)"meta"===t.type&&(this._conversationId=t.conversationId),"response.completed"!==t.type||this._conversationId||(this._conversationId=t.conversationId),"action"===t.type&&(this._pendingAction=t.action,this._status="awaiting_action"),"response.completed"===t.type&&(this._status="completed"),"error"===t.type&&(this._status="error"),this._onEvent&&this._onEvent(t),yield t;"streaming"===this._status&&(this._status=this._pendingAction?"awaiting_action":"completed")}finally{this._onComplete&&this._onComplete(this._conversationId,this._status)}}async finalResponse(){let t,e,s="",n="",r=[];for await(const a of this)switch(a.type){case"meta":n=a.conversationId;break;case"content.delta":s+=a.delta;break;case"action":e=a.action;break;case"response.completed":s=a.message,n=a.conversationId,r=a.insights,t=a.metadata;break;case"error":throw new o(a.message)}const i={message:s,conversationId:n,insights:r,metadata:t??{conversationId:n,model:"unknown",promptTokens:0,completionTokens:0,processingTimeMs:0,generatedAt:(new Date).toISOString()}};return e&&(i.action=e),i}async text(){let t="";for await(const e of this){if("content.delta"===e.type&&(t+=e.delta),"response.completed"===e.type)return e.message;if("error"===e.type)throw new o(e.message)}return t}}function h(o){return!(o instanceof t)||!(o instanceof e)&&(!(o instanceof n)&&(!(o instanceof s)&&(o instanceof r||(o instanceof a||(o instanceof i||!!(o.status&&o.status>=500))))))}function d(t,e,s){const n=e*Math.pow(2,t),r=Math.min(n,s),o=r*Math.random()*.5;return Math.floor(r+o)}function u(t){return new Promise(e=>setTimeout(e,t))}async function p(e,s){const{config:n,logger:r,onRetry:o,signal:i}=s;let a;for(let l=0;l<=n.maxRetries;l++)try{return await e()}catch(c){if(a=c,l>=n.maxRetries)break;if(!h(c))break;if(i?.aborted)break;const e=d(l,n.baseDelay,n.maxDelay);r.warn(`Retry ${l+1}/${n.maxRetries} after ${e}ms`,c instanceof Error?c.message:c),o&&c instanceof t&&o(l+1,c,e),await u(e)}throw a}class g{constructor(t,e,s,n,r){this.config=t,this.provider=e,this.getIdentity=s,this.emitter=n,this.conversationManager=r}async chat(t,e){const s=this.buildRequest(t,e),n=await p(()=>this.provider.chat(s),{config:this.config.retry,logger:this.config.logger,signal:e?.signal,onRetry:(t,e,s)=>{this.emitter.emit("retry",t,e,s)}});return n.conversationId&&this.conversationManager.setActive(n.conversationId),n}stream(e,s){const n=new AbortController,r=this.buildRequest(e,s,n.signal),o=this.provider.stream(r);this.emitter.emit("stream.start",s?.conversationId??null);return new l(o,n,e=>{if("meta"===e.type&&e.conversationId&&this.conversationManager.setActive(e.conversationId),"error"===e.type){const s=new t(e.message,"STREAM_ERROR");this.emitter.emit("error",s)}s?.onEvent&&s.onEvent(e)},t=>{this.emitter.emit("stream.end",t)})}respondToAction(t){return this.stream(t.originalMessage,{conversationId:t.conversationId,agentType:t.agentType,actionResponse:t.actionResponse,onEvent:t.onEvent,signal:t.signal})}buildRequest(t,e,s){const n=this.getIdentity(),r=e?.signal??s;return{message:t,conversationId:e?.conversationId,agentType:e?.agentType,actionResponse:e?.actionResponse,headers:this.resolveHeaders(n),signal:r,timeout:this.config.timeout}}resolveHeaders(t){const e={"x-api-key":this.config.apiKey,"x-integration-type":this.config.integrationType};t&&(t.userId&&(e["x-user-id"]=t.userId),t.participantId&&(e["x-participant-id"]=t.participantId),t.token&&(e.authorization=`Bearer ${t.token}`),t.mcpTokens&&Object.keys(t.mcpTokens).length>0&&(e["x-mcp-tokens"]=JSON.stringify(t.mcpTokens)));for(const[s,n]of Object.entries(this.config.defaultHeaders))e[s]=n;return e}}class m{constructor(){this._active=null,this._history=[]}create(){const t={id:"undefined"!=typeof crypto&&"function"==typeof crypto.randomUUID?crypto.randomUUID():"xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g,t=>{const e=16*Math.random()|0;return("x"===t?e:3&e|8).toString(16)}),createdAt:new Date};return this._history.push(t),t}get active(){return this._active}get history(){return this._history}setActive(t){const e=this._history.find(e=>e.id===t);if(e)this._active=e;else{const e={id:t,createdAt:new Date};this._history.push(e),this._active=e}}clear(){this._active=null,this._history.length=0}}class f{constructor(t){this.baseUrl=t.baseUrl.replace(/\/+$/,""),this.defaultTimeout=t.timeout,this.logger=t.logger}async json(t){const e=await this.rawFetch(t);if(!e.ok){const t=await e.text().catch(()=>"Unknown error");let s;try{const e=JSON.parse(t);s=e.message??e.error??t}catch{s=t}throw c(e.status,s,e.headers)}return e.json()}async stream(t){const e=await this.rawFetch(t);if(!e.ok){const t=await e.text().catch(()=>"Unknown error");let s;try{const e=JSON.parse(t);s=e.message??e.error??t}catch{s=t}throw c(e.status,s,e.headers)}return e}async rawFetch(t){const e=`${this.baseUrl}${t.path}`,s=t.timeout??this.defaultTimeout,n=new AbortController;let r;t.signal&&t.signal.addEventListener("abort",()=>n.abort(t.signal?.reason),{once:!0}),r=setTimeout(()=>{n.abort(new i(`Request timed out after ${s}ms`))},s);const o={"content-type":"application/json"};for(const[i,a]of Object.entries(t.headers))void 0!==a&&(o[i]=a);this.logger.debug(`${t.method} ${e}`);try{return await fetch(e,{method:t.method,headers:o,body:t.body?JSON.stringify(t.body):void 0,signal:n.signal})}catch(c){if(c instanceof i)throw c;if(c instanceof DOMException&&"AbortError"===c.name){if(n.signal.reason instanceof i)throw n.signal.reason;throw c}throw new a(c instanceof Error?c.message:"Connection failed")}finally{void 0!==r&&clearTimeout(r)}}}function y(t){let e="",s="",n="";const r=t.split("\n");for(const o of r)o.startsWith("event:")?e=o.slice(6).trim():o.startsWith("data:")?s=o.slice(5).trim():o.startsWith("id:")&&(n=o.slice(3).trim());return e||s?{event:e,data:s,id:n}:null}function v(t){const e=t.event;try{const s=t.data?JSON.parse(t.data):{};switch(e){case"meta":return{type:"meta",conversationId:s.conversationId};case"status":return{type:"status",text:s.text};case"content.delta":return{type:"content.delta",delta:s.delta};case"tool.start":return{type:"tool.start",tool:s.tool};case"tool.end":return{type:"tool.end",tool:s.tool,success:s.success};case"action":return{type:"action",action:s};case"response.completed":return{type:"response.completed",message:s.message,conversationId:s.conversationId,insights:s.insights??[],metadata:s.metadata};case"error":return{type:"error",message:s.message};case"keepalive":return{type:"keepalive",ts:s.ts};default:return null}}catch{return null}}class x{constructor(t){this.name="thaliq-native",this.logger=t.logger,this.http=new f({baseUrl:t.baseUrl,timeout:t.timeout,logger:t.logger})}async chat(t){const e={message:t.message};return t.conversationId&&(e.conversationId=t.conversationId),t.agentType&&(e.agentType=t.agentType),t.actionResponse&&(e.actionResponse=t.actionResponse),this.http.json({method:"POST",path:"/api/agent/chat",headers:t.headers,body:e,signal:t.signal,timeout:t.timeout})}async*stream(t){const e=new URLSearchParams;e.set("q",t.message),t.conversationId&&e.set("conversationId",t.conversationId),t.agentType&&e.set("agentType",t.agentType),t.actionResponse&&e.set("actionResponse",JSON.stringify(t.actionResponse));const s=await this.http.stream({method:"GET",path:`/api/agent/stream?${e.toString()}`,headers:{...t.headers,accept:"text/event-stream"},signal:t.signal,timeout:t.timeout});if(!s.body)throw new o("Response body is null — streaming not supported");this.logger.debug("SSE stream connected"),yield*async function*(t){const e=t.getReader(),s=new TextDecoder;let n="";try{for(;;){const{done:t,value:r}=await e.read();if(t)break;n+=s.decode(r,{stream:!0});const o=n.split("\n\n");n=o.pop()??"";for(const e of o){const t=y(e);if(!t)continue;const s=v(t);s&&(yield s)}}if(n.trim()){const t=y(n);if(t){const e=v(t);e&&(yield e)}}}finally{e.releaseLock()}}(s.body)}}class w{constructor(){this._listeners=new Map}on(t,e){return this._listeners.has(t)||this._listeners.set(t,new Set),this._listeners.get(t).add(e),this}once(t,e){return e._once=!0,this.on(t,e)}off(t,e){const s=this._listeners.get(t);return s&&(s.delete(e),0===s.size&&this._listeners.delete(t)),this}emit(t,...e){const s=this._listeners.get(t);if(s){for(const t of s)t(...e),t._once&&s.delete(t);0===s.size&&this._listeners.delete(t)}}removeAllListeners(t){return t?this._listeners.delete(t):this._listeners.clear(),this}listenerCount(t){return this._listeners.get(t)?.size??0}}const _={debug:0,info:1,warn:2,error:3,silent:4};const R="https://api.thaliq.com";exports.ActionResponseBuilder=class{static accept(t){return{instructionId:t,accepted:!0}}static reject(t){return{instructionId:t,accepted:!1}}static select(t,e){return{instructionId:t,accepted:!0,selectedValue:e}}static submitForm(t,e){return{instructionId:t,accepted:!0,formValues:e}}},exports.AuthError=e,exports.ConnectionError=a,exports.ConversationManager=m,exports.RateLimitError=s,exports.ServiceError=r,exports.StreamError=o,exports.Thaliq=class{constructor(t){this.emitter=new w,this.identity=null,this.config=function(t){if(!t.apiKey)throw new n("apiKey is required");const e=t.logLevel??"warn",s=t.logger??function(t){const e=_[t];return{debug(t,...s){e<=_.debug&&console.debug(`[thaliq] ${t}`,...s)},info(t,...s){e<=_.info&&console.info(`[thaliq] ${t}`,...s)},warn(t,...s){e<=_.warn&&console.warn(`[thaliq] ${t}`,...s)},error(t,...s){e<=_.error&&console.error(`[thaliq] ${t}`,...s)}}}(e),r=t.maxRetries??t.retry?.maxRetries??2;return{apiKey:t.apiKey,baseUrl:(t.baseUrl??R).replace(/\/+$/,""),integrationType:t.integrationType??"sdk",timeout:t.timeout??3e4,maxRetries:r,retry:{maxRetries:r,baseDelay:t.retry?.baseDelay??500,maxDelay:t.retry?.maxDelay??1e4},logger:s,logLevel:e,defaultHeaders:t.defaultHeaders??{}}}(t),this.provider=t.provider??new x({baseUrl:this.config.baseUrl,timeout:this.config.timeout,logger:this.config.logger}),this.conversations=new m,this.agent=new g(this.config,this.provider,()=>this.identity,this.emitter,this.conversations)}on(t,e){return this.emitter.on(t,e),this}once(t,e){return this.emitter.once(t,e),this}off(t,e){return this.emitter.off(t,e),this}identify(t){if(!t.userId)throw new n("userId is required for identify()");this.identity=t,this.config.logger.info(`User identified: ${t.userId}`),this.emitter.emit("identify",t.userId)}reset(){this.identity=null,this.conversations.clear(),this.config.logger.info("SDK state reset"),this.emitter.emit("reset")}},exports.ThaliqError=t,exports.ThaliqNativeProvider=x,exports.TimeoutError=i,exports.TypedEventEmitter=w,exports.ValidationError=n,exports.calculateBackoff=d,exports.isRetryableError=h,exports.withRetry=p;
+//# sourceMappingURL=thaliq-sdk.cjs.js.map