@mobilerun/sdk 5.2.0 → 5.3.0

package/src/internal/decoders/line.ts

@@ -0,0 +1,135 @@
+import { concatBytes, decodeUTF8, encodeUTF8 } from '../utils/bytes';
+
+export type Bytes = string | ArrayBuffer | Uint8Array | null | undefined;
+
+/**
+ * A re-implementation of httpx's `LineDecoder` in Python that handles incrementally
+ * reading lines from text.
+ *
+ * https://github.com/encode/httpx/blob/920333ea98118e9cf617f246905d7b202510941c/httpx/_decoders.py#L258
+ */
+export class LineDecoder {
+  // prettier-ignore
+  static NEWLINE_CHARS = new Set(['\n', '\r']);
+  static NEWLINE_REGEXP = /\r\n|[\n\r]/g;
+
+  #buffer: Uint8Array;
+  #carriageReturnIndex: number | null;
+
+  constructor() {
+    this.#buffer = new Uint8Array();
+    this.#carriageReturnIndex = null;
+  }
+
+  decode(chunk: Bytes): string[] {
+    if (chunk == null) {
+      return [];
+    }
+
+    const binaryChunk =
+      chunk instanceof ArrayBuffer ? new Uint8Array(chunk)
+      : typeof chunk === 'string' ? encodeUTF8(chunk)
+      : chunk;
+
+    this.#buffer = concatBytes([this.#buffer, binaryChunk]);
+
+    const lines: string[] = [];
+    let patternIndex;
+    while ((patternIndex = findNewlineIndex(this.#buffer, this.#carriageReturnIndex)) != null) {
+      if (patternIndex.carriage && this.#carriageReturnIndex == null) {
+        // skip until we either get a corresponding `\n`, a new `\r` or nothing
+        this.#carriageReturnIndex = patternIndex.index;
+        continue;
+      }
+
+      // we got double \r or \rtext\n
+      if (
+        this.#carriageReturnIndex != null &&
+        (patternIndex.index !== this.#carriageReturnIndex + 1 || patternIndex.carriage)
+      ) {
+        lines.push(decodeUTF8(this.#buffer.subarray(0, this.#carriageReturnIndex - 1)));
+        this.#buffer = this.#buffer.subarray(this.#carriageReturnIndex);
+        this.#carriageReturnIndex = null;
+        continue;
+      }
+
+      const endIndex =
+        this.#carriageReturnIndex !== null ? patternIndex.preceding - 1 : patternIndex.preceding;
+
+      const line = decodeUTF8(this.#buffer.subarray(0, endIndex));
+      lines.push(line);
+
+      this.#buffer = this.#buffer.subarray(patternIndex.index);
+      this.#carriageReturnIndex = null;
+    }
+
+    return lines;
+  }
+
+  flush(): string[] {
+    if (!this.#buffer.length) {
+      return [];
+    }
+    return this.decode('\n');
+  }
+}
+
+/**
+ * This function searches the buffer for the end patterns, (\r or \n)
+ * and returns an object with the index preceding the matched newline and the
+ * index after the newline char. `null` is returned if no new line is found.
+ *
+ * ```ts
+ * findNewLineIndex('abc\ndef') -> { preceding: 2, index: 3 }
+ * ```
+ */
+function findNewlineIndex(
+  buffer: Uint8Array,
+  startIndex: number | null,
+): { preceding: number; index: number; carriage: boolean } | null {
+  const newline = 0x0a; // \n
+  const carriage = 0x0d; // \r
+
+  for (let i = startIndex ?? 0; i < buffer.length; i++) {
+    if (buffer[i] === newline) {
+      return { preceding: i, index: i + 1, carriage: false };
+    }
+
+    if (buffer[i] === carriage) {
+      return { preceding: i, index: i + 1, carriage: true };
+    }
+  }
+
+  return null;
+}
+
+export function findDoubleNewlineIndex(buffer: Uint8Array): number {
+  // This function searches the buffer for the end patterns (\r\r, \n\n, \r\n\r\n)
+  // and returns the index right after the first occurrence of any pattern,
+  // or -1 if none of the patterns are found.
+  const newline = 0x0a; // \n
+  const carriage = 0x0d; // \r
+
+  for (let i = 0; i < buffer.length - 1; i++) {
+    if (buffer[i] === newline && buffer[i + 1] === newline) {
+      // \n\n
+      return i + 2;
+    }
+    if (buffer[i] === carriage && buffer[i + 1] === carriage) {
+      // \r\r
+      return i + 2;
+    }
+    if (
+      buffer[i] === carriage &&
+      buffer[i + 1] === newline &&
+      i + 3 < buffer.length &&
+      buffer[i + 2] === carriage &&
+      buffer[i + 3] === newline
+    ) {
+      // \r\n\r\n
+      return i + 4;
+    }
+  }
+
+  return -1;
+}

package/src/internal/parse.ts

@@ -1,6 +1,7 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 import type { FinalRequestOptions } from './request-options';
+import { Stream } from '../core/streaming';
 import { type Mobilerun } from '../client';
 import { formatRequestDetails, loggerFor } from './utils/log';
 
@@ -16,6 +17,19 @@ export type APIResponseProps = {
 export async function defaultParseResponse<T>(client: Mobilerun, props: APIResponseProps): Promise<T> {
   const { response, requestLogID, retryOfRequestLogID, startTime } = props;
   const body = await (async () => {
+    if (props.options.stream) {
+      loggerFor(client).debug('response', response.status, response.url, response.headers, response.body);
+
+      // Note: there is an invariant here that isn't represented in the type system
+      // that if you set `stream: true` the response type must also be `Stream<T>`
+
+      if (props.options.__streamClass) {
+        return props.options.__streamClass.fromSSEResponse(response, props.controller, client) as any;
+      }
+
+      return Stream.fromSSEResponse(response, props.controller, client) as any;
+    }
+
     // fetch refuses to read the body when the status code is 204.
     if (response.status === 204) {
       return null as T;

package/src/internal/request-options.ts

@@ -3,6 +3,7 @@
 import { NullableHeaders } from './headers';
 
 import type { BodyInit } from './builtin-types';
+import { Stream } from '../core/streaming';
 import type { HTTPMethod, MergedRequestInit } from './types';
 import { type HeadersLike } from './headers';
 
@@ -76,6 +77,7 @@ export type RequestOptions = {
   defaultBaseURL?: string | undefined;
 
   __binaryResponse?: boolean | undefined;
+  __streamClass?: typeof Stream;
 };
 
 export type EncodedContent = { bodyHeaders: HeadersLike; body: BodyInit };

package/src/resources/app-events/app-events.ts

@@ -0,0 +1,133 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../core/resource';
+import * as Shared from '../shared';
+import * as CatalogAPI from './catalog';
+import { Catalog, CatalogListResponse, CatalogRetrieveResponse } from './catalog';
+import { APIPromise } from '../../core/api-promise';
+import { RequestOptions } from '../../internal/request-options';
+import { path } from '../../internal/utils/path';
+
+export class AppEvents extends APIResource {
+  catalog: CatalogAPI.Catalog = new CatalogAPI.Catalog(this._client);
+
+  /**
+   * Fetch a single structured app event by its ID, including its typed payload,
+   * source, and originating device. Returns 404 if no event matches.
+   */
+  retrieve(id: string, options?: RequestOptions): APIPromise<AppEventRetrieveResponse> {
+    return this._client.get(path`/app-events/${id}`, options);
+  }
+
+  /**
+   * Structured, app-scoped events (e.g. app.whatsapp.message_received) derived from
+   * raw device notifications. Typed columns — not raw payloads (those stay in the
+   * event log).
+   */
+  list(
+    query: AppEventListParams | null | undefined = {},
+    options?: RequestOptions,
+  ): APIPromise<AppEventListResponse> {
+    return this._client.get('/app-events', { query, ...options });
+  }
+}
+
+export interface AppEventRetrieveResponse {
+  data: AppEventRetrieveResponse.Data;
+}
+
+export namespace AppEventRetrieveResponse {
+  export interface Data {
+    id: string;
+
+    createdAt: string | null;
+
+    createdBy: string | null;
+
+    deviceId: string | null;
+
+    eventType: string;
+
+    occurredAt: string | null;
+
+    ownerId: string;
+
+    payload: { [key: string]: unknown };
+
+    rawEventId: string | null;
+
+    source: 'app' | 'system' | 'device' | 'webhook';
+
+    /**
+     * @deprecated Deprecated: use ownerId (tenancy) / createdBy (actor).
+     */
+    userId: string;
+  }
+}
+
+export interface AppEventListResponse {
+  items: Array<AppEventListResponse.Item>;
+
+  pagination: Shared.Pagination;
+}
+
+export namespace AppEventListResponse {
+  export interface Item {
+    id: string;
+
+    createdAt: string | null;
+
+    createdBy: string | null;
+
+    deviceId: string | null;
+
+    eventType: string;
+
+    occurredAt: string | null;
+
+    ownerId: string;
+
+    payload: { [key: string]: unknown };
+
+    rawEventId: string | null;
+
+    source: 'app' | 'system' | 'device' | 'webhook';
+
+    /**
+     * @deprecated Deprecated: use ownerId (tenancy) / createdBy (actor).
+     */
+    userId: string;
+  }
+}
+
+export interface AppEventListParams {
+  deviceId?: string;
+
+  eventType?: string;
+
+  from?: string | null;
+
+  page?: number;
+
+  pageSize?: number;
+
+  source?: 'app' | 'system' | 'device' | 'webhook';
+
+  to?: string | null;
+}
+
+AppEvents.Catalog = Catalog;
+
+export declare namespace AppEvents {
+  export {
+    type AppEventRetrieveResponse as AppEventRetrieveResponse,
+    type AppEventListResponse as AppEventListResponse,
+    type AppEventListParams as AppEventListParams,
+  };
+
+  export {
+    Catalog as Catalog,
+    type CatalogRetrieveResponse as CatalogRetrieveResponse,
+    type CatalogListResponse as CatalogListResponse,
+  };
+}

package/src/resources/app-events/catalog.ts

@@ -0,0 +1,100 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../core/resource';
+import { APIPromise } from '../../core/api-promise';
+import { RequestOptions } from '../../internal/request-options';
+import { path } from '../../internal/utils/path';
+
+export class Catalog extends APIResource {
+  /**
+   * Fetch a single selectable app event by its appEventType (e.g.
+   * app.whatsapp.message_received).
+   */
+  retrieve(appEventType: string, options?: RequestOptions): APIPromise<CatalogRetrieveResponse> {
+    return this._client.get(path`/app-events/catalog/${appEventType}`, options);
+  }
+
+  /**
+   * Selectable app-based trigger events (e.g. app.whatsapp.message_received) with
+   * their predefined payload — served from the JSON definition registry (always in
+   * sync, no DB).
+   */
+  list(options?: RequestOptions): APIPromise<CatalogListResponse> {
+    return this._client.get('/app-events/catalog', options);
+  }
+}
+
+export interface CatalogRetrieveResponse {
+  data: CatalogRetrieveResponse.Data;
+}
+
+export namespace CatalogRetrieveResponse {
+  export interface Data {
+    appEventType: string;
+
+    appName: string;
+
+    category: 'app' | 'system' | 'device' | 'webhook';
+
+    label: string;
+
+    packageName: string | null;
+
+    payloadSchema: Array<Data.PayloadSchema>;
+
+    sourceEventType: string;
+  }
+
+  export namespace Data {
+    export interface PayloadSchema {
+      description: string;
+
+      name: string;
+
+      type: 'string' | 'number' | 'boolean' | 'object' | 'array';
+
+      example?: unknown;
+    }
+  }
+}
+
+export interface CatalogListResponse {
+  data: Array<CatalogListResponse.Data>;
+}
+
+export namespace CatalogListResponse {
+  export interface Data {
+    appEventType: string;
+
+    appName: string;
+
+    category: 'app' | 'system' | 'device' | 'webhook';
+
+    label: string;
+
+    packageName: string | null;
+
+    payloadSchema: Array<Data.PayloadSchema>;
+
+    sourceEventType: string;
+  }
+
+  export namespace Data {
+    export interface PayloadSchema {
+      description: string;
+
+      name: string;
+
+      type: 'string' | 'number' | 'boolean' | 'object' | 'array';
+
+      example?: unknown;
+    }
+  }
+}
+
+export declare namespace Catalog {
+  export {
+    type CatalogRetrieveResponse as CatalogRetrieveResponse,
+    type CatalogListResponse as CatalogListResponse,
+  };
+}

package/src/resources/app-events/index.ts

@@ -0,0 +1,9 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export {
+  AppEvents,
+  type AppEventRetrieveResponse,
+  type AppEventListResponse,
+  type AppEventListParams,
+} from './app-events';
+export { Catalog, type CatalogRetrieveResponse, type CatalogListResponse } from './catalog';

package/src/resources/app-events.ts

@@ -0,0 +1,3 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export * from './app-events/index';

package/src/resources/apps.ts

@@ -119,6 +119,19 @@ export class Apps extends APIResource {
   markFailed(id: string, options?: RequestOptions): APIPromise<AppMarkFailedResponse> {
     return this._client.post(path`/apps/${id}/mark-failed`, options);
   }
+
+  /**
+   * Returns the user’s total storage quota, bytes used, and remaining bytes — the
+   * reliable maximum size for the next upload.
+   *
+   * @example
+   * ```ts
+   * const response = await client.apps.storageUsage();
+   * ```
+   */
+  storageUsage(options?: RequestOptions): APIPromise<AppStorageUsageResponse> {
+    return this._client.get('/apps/storage-usage', options);
+  }
 }
 
 export interface AppRetrieveResponse {
@@ -458,7 +471,7 @@ export namespace AppListResponse {
 
       sizeBytes: number | null;
 
-      source: 'user' | 'system' | 'portal' | 'store';
+      source: 'user' | 'system' | 'portal' | 'store' | 'catalog';
 
       status: 'queued' | 'available' | 'failed';
 
@@ -789,7 +802,7 @@ export namespace AppListVersionsResponse {
 
     sizeBytes: number | null;
 
-    source: 'user' | 'system' | 'portal' | 'store';
+    source: 'user' | 'system' | 'portal' | 'store' | 'catalog';
 
     status: 'queued' | 'available' | 'failed';
 
@@ -814,6 +827,31 @@ export interface AppMarkFailedResponse {
   success: true;
 }
 
+export interface AppStorageUsageResponse {
+  data: AppStorageUsageResponse.Data;
+}
+
+export namespace AppStorageUsageResponse {
+  export interface Data {
+    /**
+     * Remaining bytes — the reliable maximum size for the next upload. Advisory
+     * snapshot: the quota is enforced under a lock at confirm, so concurrent uploads
+     * may reduce actual headroom.
+     */
+    availableBytes: number;
+
+    /**
+     * Total storage allowance for the user, in bytes
+     */
+    quotaBytes: number;
+
+    /**
+     * Bytes currently consumed across all of the user’s app versions
+     */
+    usedBytes: number;
+  }
+}
+
 export interface AppListParams {
   order?: 'asc' | 'desc';
 
@@ -876,6 +914,7 @@ export declare namespace Apps {
     type AppCreateSignedUploadURLResponse as AppCreateSignedUploadURLResponse,
     type AppListVersionsResponse as AppListVersionsResponse,
     type AppMarkFailedResponse as AppMarkFailedResponse,
+    type AppStorageUsageResponse as AppStorageUsageResponse,
     type AppListParams as AppListParams,
     type AppCreateSignedUploadURLParams as AppCreateSignedUploadURLParams,
   };

package/src/resources/assistant/assistant.ts

@@ -0,0 +1,59 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../core/resource';
+import * as ConversationsAPI from './conversations';
+import {
+  ConversationAbortParams,
+  ConversationAbortResponse,
+  ConversationAnswerPermissionParams,
+  ConversationAnswerPermissionResponse,
+  ConversationAnswerQuestionParams,
+  ConversationAnswerQuestionResponse,
+  ConversationCreateParams,
+  ConversationCreateResponse,
+  ConversationHistoryParams,
+  ConversationHistoryResponse,
+  ConversationListParams,
+  ConversationListResponse,
+  ConversationRejectQuestionParams,
+  ConversationRejectQuestionResponse,
+  ConversationSendParams,
+  ConversationSendResponse,
+  ConversationStreamParams,
+  ConversationStreamResponse,
+  ConversationUpdateParams,
+  ConversationUpdateResponse,
+  Conversations,
+} from './conversations';
+
+export class Assistant extends APIResource {
+  conversations: ConversationsAPI.Conversations = new ConversationsAPI.Conversations(this._client);
+}
+
+Assistant.Conversations = Conversations;
+
+export declare namespace Assistant {
+  export {
+    Conversations as Conversations,
+    type ConversationCreateResponse as ConversationCreateResponse,
+    type ConversationUpdateResponse as ConversationUpdateResponse,
+    type ConversationListResponse as ConversationListResponse,
+    type ConversationAbortResponse as ConversationAbortResponse,
+    type ConversationAnswerPermissionResponse as ConversationAnswerPermissionResponse,
+    type ConversationAnswerQuestionResponse as ConversationAnswerQuestionResponse,
+    type ConversationHistoryResponse as ConversationHistoryResponse,
+    type ConversationRejectQuestionResponse as ConversationRejectQuestionResponse,
+    type ConversationSendResponse as ConversationSendResponse,
+    type ConversationStreamResponse as ConversationStreamResponse,
+    type ConversationCreateParams as ConversationCreateParams,
+    type ConversationUpdateParams as ConversationUpdateParams,
+    type ConversationListParams as ConversationListParams,
+    type ConversationAbortParams as ConversationAbortParams,
+    type ConversationAnswerPermissionParams as ConversationAnswerPermissionParams,
+    type ConversationAnswerQuestionParams as ConversationAnswerQuestionParams,
+    type ConversationHistoryParams as ConversationHistoryParams,
+    type ConversationRejectQuestionParams as ConversationRejectQuestionParams,
+    type ConversationSendParams as ConversationSendParams,
+    type ConversationStreamParams as ConversationStreamParams,
+  };
+}