@spekoai/sdk 0.4.3 → 0.5.2

package/dist/lib/resources/sessions.d.ts

@@ -0,0 +1,53 @@
+import type { HttpClient } from '../http.js';
+import type { EndCallResult, SessionStreamEvent, SessionStreamOptions, SessionTranscript } from '../types/index.js';
+/**
+ * Session-scoped reads. A `sessionId` is the id returned by
+ * `voice.dial(...)` / session create — the same id `calls.*` accepts.
+ */
+export declare class Sessions {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * End a live session now (kill switch): tears the room down, which drops
+     * every participant; the normal close + metering flow runs server-side.
+     * Works for any session kind — browser/WebRTC sessions included. Alias of
+     * `calls.end()`, which accepts the same session id. Resolves with
+     * `status: 'ending'` once teardown is requested, or
+     * `status: 'already_ended'` if the session was over. Use this from your
+     * backend to stop billing for a session your client can no longer reach
+     * (for example an abandoned browser tab).
+     */
+    end(sessionId: string): Promise<EndCallResult>;
+    /**
+     * Transcript of a session, oldest turn first — the point-in-time snapshot.
+     * For live consumption prefer `stream()`, which pushes each turn as it
+     * lands; this endpoint stays the final word on per-turn latency numbers
+     * (legs keep enriching after a turn is first written).
+     */
+    transcript(sessionId: string): Promise<SessionTranscript>;
+    /**
+     * Observe a session live: transcript turns, call events, and status changes
+     * pushed as they happen (SSE under the hood). Iterate until `end` — the
+     * SDK reconnects through server stream rotations and transient drops with
+     * an internal cursor, so consumers never poll and never see duplicates.
+     *
+     * ```ts
+     * for await (const ev of speko.sessions.stream(sessionId)) {
+     *   if (ev.type === 'transcript') render(ev.turn);
+     *   if (ev.type === 'event') timeline(ev.event.event_type);
+     *   if (ev.type === 'end') break; // session over
+     * }
+     * ```
+     *
+     * A stream opened on an already-ended session replays the backlog and then
+     * ends, so late subscribers converge on the same picture.
+     *
+     * The no-duplicates guarantee holds per iterator: reconnects re-read a
+     * short server-side overlap window, and this iterator filters the replays
+     * by event id. A brand-new iterator resumed via `options.cursor` (process
+     * restart) starts with no memory and may replay up to ~2 s of events —
+     * dedupe by `event.id` if that matters to you.
+     */
+    stream(sessionId: string, options?: SessionStreamOptions): AsyncIterableIterator<SessionStreamEvent>;
+}
+//# sourceMappingURL=sessions.d.ts.map

package/dist/lib/resources/sessions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sessions.d.ts","sourceRoot":"","sources":["../../../src/lib/resources/sessions.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAC7C,OAAO,KAAK,EAEV,aAAa,EACb,kBAAkB,EAClB,oBAAoB,EACpB,iBAAiB,EAElB,MAAM,mBAAmB,CAAC;AAW3B;;;GAGG;AACH,qBAAa,QAAQ;IACP,OAAO,CAAC,QAAQ,CAAC,IAAI;gBAAJ,IAAI,EAAE,UAAU;IAE7C;;;;;;;;;OASG;IACH,GAAG,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;IAI9C;;;;;OAKG;IACH,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAMzD;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACI,MAAM,CACX,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE,oBAAyB,GACjC,qBAAqB,CAAC,kBAAkB,CAAC;CA+G7C"}

package/dist/lib/resources/sessions.js

@@ -0,0 +1,166 @@
+import { SpekoApiError } from '../errors.js';
+/** Consecutive failed connect attempts (no frame received) before giving up. */
+const MAX_RECONNECT_ATTEMPTS = 10;
+/**
+ * Per-connection cap, above the server's own stream rotation (10 min +
+ * `end {reason:'timeout'}`) so the server always rotates first and this
+ * client-side abort only nets a server that went quiet.
+ */
+const STREAM_REQUEST_TIMEOUT_MS = 15 * 60_000;
+/**
+ * Session-scoped reads. A `sessionId` is the id returned by
+ * `voice.dial(...)` / session create — the same id `calls.*` accepts.
+ */
+export class Sessions {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    /**
+     * End a live session now (kill switch): tears the room down, which drops
+     * every participant; the normal close + metering flow runs server-side.
+     * Works for any session kind — browser/WebRTC sessions included. Alias of
+     * `calls.end()`, which accepts the same session id. Resolves with
+     * `status: 'ending'` once teardown is requested, or
+     * `status: 'already_ended'` if the session was over. Use this from your
+     * backend to stop billing for a session your client can no longer reach
+     * (for example an abandoned browser tab).
+     */
+    end(sessionId) {
+        return this.http.post(`/v1/calls/${encodeURIComponent(sessionId)}/end`, {});
+    }
+    /**
+     * Transcript of a session, oldest turn first — the point-in-time snapshot.
+     * For live consumption prefer `stream()`, which pushes each turn as it
+     * lands; this endpoint stays the final word on per-turn latency numbers
+     * (legs keep enriching after a turn is first written).
+     */
+    transcript(sessionId) {
+        return this.http.get(`/v1/sessions/${encodeURIComponent(sessionId)}/transcript`);
+    }
+    /**
+     * Observe a session live: transcript turns, call events, and status changes
+     * pushed as they happen (SSE under the hood). Iterate until `end` — the
+     * SDK reconnects through server stream rotations and transient drops with
+     * an internal cursor, so consumers never poll and never see duplicates.
+     *
+     * ```ts
+     * for await (const ev of speko.sessions.stream(sessionId)) {
+     *   if (ev.type === 'transcript') render(ev.turn);
+     *   if (ev.type === 'event') timeline(ev.event.event_type);
+     *   if (ev.type === 'end') break; // session over
+     * }
+     * ```
+     *
+     * A stream opened on an already-ended session replays the backlog and then
+     * ends, so late subscribers converge on the same picture.
+     *
+     * The no-duplicates guarantee holds per iterator: reconnects re-read a
+     * short server-side overlap window, and this iterator filters the replays
+     * by event id. A brand-new iterator resumed via `options.cursor` (process
+     * restart) starts with no memory and may replay up to ~2 s of events —
+     * dedupe by `event.id` if that matters to you.
+     */
+    async *stream(sessionId, options = {}) {
+        // Cursor is derived from payloads (max turn index / max event created_at),
+        // so resume needs no SSE `id:` plumbing in the shared HTTP client.
+        let turnIndex = -1;
+        let eventMs = 0;
+        if (options.cursor) {
+            const m = /^(-?\d+):(\d+)$/.exec(options.cursor.trim());
+            if (m?.[1] !== undefined && m[2] !== undefined) {
+                turnIndex = Number(m[1]);
+                eventMs = Number(m[2]);
+            }
+        }
+        // Every reconnect re-reads the server's overlap window (its own dedupe
+        // state dies with the response), so the iterator remembers delivered
+        // event ids to keep replays away from the consumer. Retention is by the
+        // EVENT's timestamp falling behind the cursor window — the same invariant
+        // the server uses — never by count: a capacity ring can evict ids that a
+        // reconnect is still allowed to replay (a >capacity burst inside the
+        // overlap window), reintroducing duplicates. All timestamps are
+        // DB-stamped, so no client clock is involved; the horizon just needs to
+        // comfortably exceed the server's 2 s overlap re-read. Turns need no
+        // dedupe — their cursor (`index`) is exact and resumed with strict `>`.
+        const SEEN_EVENT_WINDOW_MS = 10_000;
+        const seenEvents = new Map();
+        const rememberEvent = (id, createdMs) => {
+            seenEvents.set(id, Number.isFinite(createdMs) ? createdMs : eventMs);
+            for (const [seenId, seenMs] of seenEvents) {
+                if (seenMs < eventMs - SEEN_EVENT_WINDOW_MS)
+                    seenEvents.delete(seenId);
+            }
+        };
+        let failedAttempts = 0;
+        while (true) {
+            if (options.signal?.aborted)
+                return;
+            let receivedFrame = false;
+            try {
+                const path = `/v1/sessions/${encodeURIComponent(sessionId)}/stream` +
+                    `?cursor=${turnIndex}:${eventMs}`;
+                const frames = this.http.requestSse('GET', path, undefined, options.signal, { Accept: 'text/event-stream' }, STREAM_REQUEST_TIMEOUT_MS);
+                for await (const frame of frames) {
+                    receivedFrame = true;
+                    failedAttempts = 0;
+                    switch (frame.event) {
+                        case 'status': {
+                            const data = frame.data;
+                            yield { type: 'status', status: data.status, endedAt: data.endedAt ?? null };
+                            break;
+                        }
+                        case 'transcript': {
+                            const turn = frame.data;
+                            turnIndex = Math.max(turnIndex, turn.index);
+                            yield { type: 'transcript', turn };
+                            break;
+                        }
+                        case 'event': {
+                            const event = frame.data;
+                            const createdMs = Date.parse(event.created_at);
+                            if (Number.isFinite(createdMs))
+                                eventMs = Math.max(eventMs, createdMs);
+                            if (seenEvents.has(event.id))
+                                break;
+                            rememberEvent(event.id, createdMs);
+                            yield { type: 'event', event };
+                            break;
+                        }
+                        case 'end': {
+                            const data = frame.data;
+                            if (data.reason === 'session_ended') {
+                                yield { type: 'end', reason: 'session_ended' };
+                                return;
+                            }
+                            // 'timeout' is the server rotating a long response — reconnect.
+                            break;
+                        }
+                        default:
+                            // 'error' or unknown frame: the server closes after these;
+                            // fall through to the reconnect path below.
+                            break;
+                    }
+                }
+            }
+            catch (err) {
+                if (options.signal?.aborted)
+                    return;
+                // Auth failures and unknown sessions are not transient — surface them.
+                if (err instanceof SpekoApiError && err.status >= 400 && err.status < 500) {
+                    throw err;
+                }
+                // Anything else (network drop, mid-stream abort) → reconnect below.
+            }
+            if (options.signal?.aborted)
+                return;
+            if (!receivedFrame) {
+                failedAttempts += 1;
+                if (failedAttempts >= MAX_RECONNECT_ATTEMPTS) {
+                    throw new SpekoApiError(`session stream: ${MAX_RECONNECT_ATTEMPTS} consecutive reconnect attempts failed`, 0, 'STREAM_DISCONNECTED');
+                }
+            }
+            await new Promise((resolve) => setTimeout(resolve, Math.min(500 * Math.max(failedAttempts, 1), 5000)));
+        }
+    }
+}

package/dist/lib/resources/sms.d.ts

@@ -0,0 +1,80 @@
+import type { HttpClient } from '../http.js';
+import type { SmsBatch, SmsBatchCreateParams, SmsConsent, SmsConsentInput, SmsConsentListParams, SmsConversation, SmsConversationListParams, SmsConversationNote, SmsConversationSendParams, SmsConversationUpdate, SmsMessage, SmsMessageListParams, SmsPage, SmsSendParams, SmsSettings, SmsSettingsUpdate, SmsStreamEvent, SmsSuppression } from '../types/index.js';
+export declare class Sms {
+    private readonly http;
+    readonly messages: SmsMessages;
+    readonly batches: SmsBatches;
+    readonly conversations: SmsConversations;
+    readonly consents: SmsConsents;
+    readonly suppressions: SmsSuppressions;
+    readonly settings: SmsSettingsResource;
+    constructor(http: HttpClient);
+    stream(options?: {
+        lastEventId?: string;
+        signal?: AbortSignal;
+    }): AsyncIterableIterator<SmsStreamEvent>;
+}
+export declare class SmsMessages {
+    private readonly http;
+    constructor(http: HttpClient);
+    send(params: SmsSendParams): Promise<SmsMessage>;
+    list(params?: SmsMessageListParams): Promise<SmsPage<SmsMessage>>;
+    get(messageId: string): Promise<SmsMessage>;
+    cancel(messageId: string): Promise<SmsMessage>;
+}
+export declare class SmsBatches {
+    private readonly http;
+    constructor(http: HttpClient);
+    create(params: SmsBatchCreateParams): Promise<SmsBatch>;
+    get(batchId: string): Promise<SmsBatch>;
+    messages(batchId: string, params?: {
+        cursor?: string;
+        limit?: number;
+    }): Promise<SmsPage<SmsMessage>>;
+    cancel(batchId: string): Promise<SmsBatch>;
+}
+export declare class SmsConversations {
+    private readonly http;
+    constructor(http: HttpClient);
+    list(params?: SmsConversationListParams): Promise<SmsPage<SmsConversation>>;
+    get(conversationId: string): Promise<SmsConversation>;
+    messages(conversationId: string, params?: {
+        cursor?: string;
+        limit?: number;
+    }): Promise<SmsPage<SmsMessage>>;
+    send(conversationId: string, params: SmsConversationSendParams): Promise<SmsMessage>;
+    update(conversationId: string, params: SmsConversationUpdate): Promise<SmsConversation>;
+    markRead(conversationId: string): Promise<SmsConversation>;
+    addNote(conversationId: string, body: string): Promise<SmsConversationNote>;
+    notes(conversationId: string, params?: {
+        limit?: number;
+    }): Promise<SmsPage<SmsConversationNote>>;
+    redact(conversationId: string): Promise<void>;
+}
+export declare class SmsConsents {
+    private readonly http;
+    constructor(http: HttpClient);
+    list(params?: SmsConsentListParams): Promise<SmsPage<SmsConsent>>;
+    create(params: SmsConsentInput): Promise<SmsConsent>;
+    import(records: readonly SmsConsentInput[]): Promise<{
+        data: SmsConsent[];
+        imported: number;
+    }>;
+    revoke(consentId: string, reason?: string): Promise<SmsConsent>;
+}
+export declare class SmsSuppressions {
+    private readonly http;
+    constructor(http: HttpClient);
+    list(params?: {
+        recipient?: string;
+        active?: boolean;
+        limit?: number;
+    }): Promise<SmsPage<SmsSuppression>>;
+}
+export declare class SmsSettingsResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    get(): Promise<SmsSettings | null>;
+    update(params: SmsSettingsUpdate): Promise<SmsSettings>;
+}
+//# sourceMappingURL=sms.d.ts.map

package/dist/lib/resources/sms.d.ts.map

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

package/dist/lib/resources/sms.js

@@ -0,0 +1,152 @@
+export class Sms {
+    http;
+    messages;
+    batches;
+    conversations;
+    consents;
+    suppressions;
+    settings;
+    constructor(http) {
+        this.http = http;
+        this.messages = new SmsMessages(http);
+        this.batches = new SmsBatches(http);
+        this.conversations = new SmsConversations(http);
+        this.consents = new SmsConsents(http);
+        this.suppressions = new SmsSuppressions(http);
+        this.settings = new SmsSettingsResource(http);
+    }
+    async *stream(options = {}) {
+        const headers = options.lastEventId ? { 'Last-Event-ID': options.lastEventId } : undefined;
+        for await (const event of this.http.requestSse('GET', '/v1/sms/stream', undefined, options.signal, headers, 0)) {
+            if (event.event === 'heartbeat')
+                continue;
+            const data = event.data;
+            yield { event: event.event, ...(event.id ? { id: event.id } : {}), ...data };
+        }
+    }
+}
+export class SmsMessages {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    send(params) {
+        const { idempotencyKey, ...body } = params;
+        return this.http.post('/v1/sms/messages', body, undefined, {
+            'Idempotency-Key': idempotencyKey,
+        });
+    }
+    list(params = {}) {
+        return this.http.get(`/v1/sms/messages${query(params)}`);
+    }
+    get(messageId) {
+        return this.http.get(`/v1/sms/messages/${encodeURIComponent(messageId)}`);
+    }
+    cancel(messageId) {
+        return this.http.post(`/v1/sms/messages/${encodeURIComponent(messageId)}/cancel`, {});
+    }
+}
+export class SmsBatches {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    create(params) {
+        const { idempotencyKey, ...body } = params;
+        return this.http.post('/v1/sms/batches', body, undefined, {
+            'Idempotency-Key': idempotencyKey,
+        });
+    }
+    get(batchId) {
+        return this.http.get(`/v1/sms/batches/${encodeURIComponent(batchId)}`);
+    }
+    messages(batchId, params = {}) {
+        return this.http.get(`/v1/sms/batches/${encodeURIComponent(batchId)}/messages${query(params)}`);
+    }
+    cancel(batchId) {
+        return this.http.post(`/v1/sms/batches/${encodeURIComponent(batchId)}/cancel`, {});
+    }
+}
+export class SmsConversations {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    list(params = {}) {
+        return this.http.get(`/v1/sms/conversations${query(params)}`);
+    }
+    get(conversationId) {
+        return this.http.get(`/v1/sms/conversations/${encodeURIComponent(conversationId)}`);
+    }
+    messages(conversationId, params = {}) {
+        return this.http.get(`/v1/sms/conversations/${encodeURIComponent(conversationId)}/messages${query(params)}`);
+    }
+    send(conversationId, params) {
+        const { idempotencyKey, ...body } = params;
+        return this.http.post(`/v1/sms/conversations/${encodeURIComponent(conversationId)}/messages`, body, undefined, { 'Idempotency-Key': idempotencyKey });
+    }
+    update(conversationId, params) {
+        return this.http.patch(`/v1/sms/conversations/${encodeURIComponent(conversationId)}`, params);
+    }
+    markRead(conversationId) {
+        return this.http.post(`/v1/sms/conversations/${encodeURIComponent(conversationId)}/read`, {});
+    }
+    addNote(conversationId, body) {
+        return this.http.post(`/v1/sms/conversations/${encodeURIComponent(conversationId)}/notes`, {
+            body,
+        });
+    }
+    notes(conversationId, params = {}) {
+        return this.http.get(`/v1/sms/conversations/${encodeURIComponent(conversationId)}/notes${query(params)}`);
+    }
+    async redact(conversationId) {
+        await this.http.delete(`/v1/sms/conversations/${encodeURIComponent(conversationId)}`);
+    }
+}
+export class SmsConsents {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    list(params = {}) {
+        return this.http.get(`/v1/sms/consents${query(params)}`);
+    }
+    create(params) {
+        return this.http.post('/v1/sms/consents', params);
+    }
+    import(records) {
+        return this.http.post('/v1/sms/consents/import', { records });
+    }
+    revoke(consentId, reason = 'manual_revocation') {
+        return this.http.post(`/v1/sms/consents/${encodeURIComponent(consentId)}/revoke`, { reason });
+    }
+}
+export class SmsSuppressions {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    list(params = {}) {
+        return this.http.get(`/v1/sms/suppressions${query(params)}`);
+    }
+}
+export class SmsSettingsResource {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    get() {
+        return this.http.get('/v1/sms/settings');
+    }
+    update(params) {
+        return this.http.patch('/v1/sms/settings', params);
+    }
+}
+function query(params) {
+    const search = new URLSearchParams();
+    for (const [key, value] of Object.entries(params)) {
+        if (value !== undefined && value !== null)
+            search.set(key, String(value));
+    }
+    return search.size ? `?${search.toString()}` : '';
+}

package/dist/lib/resources/synthesize.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"synthesize.d.ts","sourceRoot":"","sources":["../../../src/lib/resources/synthesize.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAC7C,OAAO,KAAK,EACV,iBAAiB,EACjB,gBAAgB,EAChB,sBAAsB,EACvB,MAAM,mBAAmB,CAAC;AAE3B,qBAAa,UAAU;IACT,OAAO,CAAC,QAAQ,CAAC,IAAI;gBAAJ,IAAI,EAAE,UAAU;IAE7C;;;;;;;;;;;;;;;OAeG;IACG,IAAI,CACR,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,iBAAiB,EAC1B,WAAW,CAAC,EAAE,WAAW,GACxB,OAAO,CAAC,gBAAgB,CAAC;IAiBtB,MAAM,CACV,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,iBAAiB,EAC1B,WAAW,CAAC,EAAE,WAAW,GACxB,OAAO,CAAC,sBAAsB,CAAC;CAiCnC"}
+{"version":3,"file":"synthesize.d.ts","sourceRoot":"","sources":["../../../src/lib/resources/synthesize.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAC7C,OAAO,KAAK,EACV,iBAAiB,EACjB,gBAAgB,EAChB,sBAAsB,EACvB,MAAM,mBAAmB,CAAC;AAE3B,qBAAa,UAAU;IACT,OAAO,CAAC,QAAQ,CAAC,IAAI;gBAAJ,IAAI,EAAE,UAAU;IAE7C;;;;;;;;;;;;;;;OAeG;IACG,IAAI,CACR,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,iBAAiB,EAC1B,WAAW,CAAC,EAAE,WAAW,GACxB,OAAO,CAAC,gBAAgB,CAAC;IAiBtB,MAAM,CACV,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,iBAAiB,EAC1B,WAAW,CAAC,EAAE,WAAW,GACxB,OAAO,CAAC,sBAAsB,CAAC;CAsCnC"}

package/dist/lib/resources/synthesize.js

@@ -35,6 +35,8 @@ export class Synthesize {
         };
     }
     async stream(text, options, abortSignal) {
+        const trimmedSessionId = options.sessionId?.trim();
+        const requestHeaders = trimmedSessionId ? { 'x-session-id': trimmedSessionId } : undefined;
         const intent = {
             language: options.language,
             ...(options.region !== undefined && { region: options.region }),
@@ -47,15 +49,19 @@ export class Synthesize {
             body['model'] = options.model;
         if (options.speed !== undefined)
             body['speed'] = options.speed;
+        if (options.instructions !== undefined)
+            body['instructions'] = options.instructions;
+        if (options.spokenForm !== undefined)
+            body['spokenForm'] = options.spokenForm;
         if (options.constraints !== undefined)
             body['constraints'] = options.constraints;
-        const { chunks, headers } = await this.http.requestBinaryStream('POST', '/v1/synthesize', body, abortSignal);
+        const { chunks, headers: responseHeaders } = await this.http.requestBinaryStream('POST', '/v1/synthesize', body, abortSignal, requestHeaders);
         const result = {
-            contentType: headers['content-type'] ?? 'application/octet-stream',
-            provider: headers['x-speko-provider'] ?? 'unknown',
-            model: headers['x-speko-model'] ?? 'unknown',
-            failoverCount: parseInt(headers['x-speko-failover-count'] ?? '0', 10),
-            scoresRunId: headers['x-speko-scores-run-id'] || null,
+            contentType: responseHeaders['content-type'] ?? 'application/octet-stream',
+            provider: responseHeaders['x-speko-provider'] ?? 'unknown',
+            model: responseHeaders['x-speko-model'] ?? 'unknown',
+            failoverCount: parseInt(responseHeaders['x-speko-failover-count'] ?? '0', 10),
+            scoresRunId: responseHeaders['x-speko-scores-run-id'] || null,
             [Symbol.asyncIterator]() {
                 return chunks;
             },

package/dist/lib/resources/transcribe.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transcribe.d.ts","sourceRoot":"","sources":["../../../src/lib/resources/transcribe.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAC7C,OAAO,KAAK,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAEpG,qBAAa,UAAU;IACT,OAAO,CAAC,QAAQ,CAAC,IAAI;gBAAJ,IAAI,EAAE,UAAU;IAE7C;;;;;;;;;;;OAWG;IACG,IAAI,CACR,KAAK,EAAE,UAAU,EACjB,OAAO,EAAE,iBAAiB,EAC1B,WAAW,CAAC,EAAE,WAAW,GACxB,OAAO,CAAC,gBAAgB,CAAC;IAsBrB,MAAM,CACX,KAAK,EAAE,UAAU,EACjB,OAAO,EAAE,iBAAiB,EAC1B,WAAW,CAAC,EAAE,WAAW,GACxB,qBAAqB,CAAC,qBAAqB,CAAC;CAkChD"}
+{"version":3,"file":"transcribe.d.ts","sourceRoot":"","sources":["../../../src/lib/resources/transcribe.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAC7C,OAAO,KAAK,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAEpG,qBAAa,UAAU;IACT,OAAO,CAAC,QAAQ,CAAC,IAAI;gBAAJ,IAAI,EAAE,UAAU;IAE7C;;;;;;;;;;;OAWG;IACG,IAAI,CACR,KAAK,EAAE,UAAU,EACjB,OAAO,EAAE,iBAAiB,EAC1B,WAAW,CAAC,EAAE,WAAW,GACxB,OAAO,CAAC,gBAAgB,CAAC;IAsBrB,MAAM,CACX,KAAK,EAAE,UAAU,EACjB,OAAO,EAAE,iBAAiB,EAC1B,WAAW,CAAC,EAAE,WAAW,GACxB,qBAAqB,CAAC,qBAAqB,CAAC;CAyChD"}

package/dist/lib/resources/transcribe.js

@@ -48,12 +48,19 @@ export class Transcribe {
             'Content-Type': options.contentType ?? 'audio/wav',
             'X-Speko-Intent': JSON.stringify(intent),
         };
+        const trimmedSessionId = options.sessionId?.trim();
+        if (trimmedSessionId) {
+            headers['x-session-id'] = trimmedSessionId;
+        }
         if (options.constraints) {
             headers['X-Speko-Constraints'] = JSON.stringify(options.constraints);
         }
-        if (options.keywords && options.keywords.length > 0) {
+        const keywords = options.keywords && options.keywords.length > 0 ? options.keywords : undefined;
+        const sttLanguage = options.sttOptions?.language;
+        if (keywords !== undefined || sttLanguage !== undefined) {
             headers['X-Speko-Stt-Options'] = JSON.stringify({
-                keywords: [...options.keywords],
+                ...(keywords !== undefined && { keywords: [...keywords] }),
+                ...(sttLanguage !== undefined && { language: sttLanguage }),
             });
         }
         const stream = await this.http.requestRawSse('POST', '/v1/transcribe', audio, headers, abortSignal);