@honcho-ai/core 1.0.0

package/src/error.ts

@@ -0,0 +1,130 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { castToError, Headers } from "./core.js";
+
+export class HonchoError extends Error {}
+
+export class APIError<
+  TStatus extends number | undefined = number | undefined,
+  THeaders extends Headers | undefined = Headers | undefined,
+  TError extends Object | undefined = Object | undefined,
+> extends HonchoError {
+  /** HTTP status for the response that caused the error */
+  readonly status: TStatus;
+  /** HTTP headers for the response that caused the error */
+  readonly headers: THeaders;
+  /** JSON body of the response that caused the error */
+  readonly error: TError;
+
+  constructor(status: TStatus, error: TError, message: string | undefined, headers: THeaders) {
+    super(`${APIError.makeMessage(status, error, message)}`);
+    this.status = status;
+    this.headers = headers;
+    this.error = error;
+  }
+
+  private static makeMessage(status: number | undefined, error: any, message: string | undefined) {
+    const msg =
+      error?.message ?
+        typeof error.message === 'string' ?
+          error.message
+        : JSON.stringify(error.message)
+      : error ? JSON.stringify(error)
+      : message;
+
+    if (status && msg) {
+      return `${status} ${msg}`;
+    }
+    if (status) {
+      return `${status} status code (no body)`;
+    }
+    if (msg) {
+      return msg;
+    }
+    return '(no status code or body)';
+  }
+
+  static generate(
+    status: number | undefined,
+    errorResponse: Object | undefined,
+    message: string | undefined,
+    headers: Headers | undefined,
+  ): APIError {
+    if (!status || !headers) {
+      return new APIConnectionError({ message, cause: castToError(errorResponse) });
+    }
+
+    const error = errorResponse as Record<string, any>;
+
+    if (status === 400) {
+      return new BadRequestError(status, error, message, headers);
+    }
+
+    if (status === 401) {
+      return new AuthenticationError(status, error, message, headers);
+    }
+
+    if (status === 403) {
+      return new PermissionDeniedError(status, error, message, headers);
+    }
+
+    if (status === 404) {
+      return new NotFoundError(status, error, message, headers);
+    }
+
+    if (status === 409) {
+      return new ConflictError(status, error, message, headers);
+    }
+
+    if (status === 422) {
+      return new UnprocessableEntityError(status, error, message, headers);
+    }
+
+    if (status === 429) {
+      return new RateLimitError(status, error, message, headers);
+    }
+
+    if (status >= 500) {
+      return new InternalServerError(status, error, message, headers);
+    }
+
+    return new APIError(status, error, message, headers);
+  }
+}
+
+export class APIUserAbortError extends APIError<undefined, undefined, undefined> {
+  constructor({ message }: { message?: string } = {}) {
+    super(undefined, undefined, message || 'Request was aborted.', undefined);
+  }
+}
+
+export class APIConnectionError extends APIError<undefined, undefined, undefined> {
+  constructor({ message, cause }: { message?: string | undefined; cause?: Error | undefined }) {
+    super(undefined, undefined, message || 'Connection error.', undefined);
+    // in some environments the 'cause' property is already declared
+    // @ts-ignore
+    if (cause) this.cause = cause;
+  }
+}
+
+export class APIConnectionTimeoutError extends APIConnectionError {
+  constructor({ message }: { message?: string } = {}) {
+    super({ message: message ?? 'Request timed out.' });
+  }
+}
+
+export class BadRequestError extends APIError<400, Headers> {}
+
+export class AuthenticationError extends APIError<401, Headers> {}
+
+export class PermissionDeniedError extends APIError<403, Headers> {}
+
+export class NotFoundError extends APIError<404, Headers> {}
+
+export class ConflictError extends APIError<409, Headers> {}
+
+export class UnprocessableEntityError extends APIError<422, Headers> {}
+
+export class RateLimitError extends APIError<429, Headers> {}
+
+export class InternalServerError extends APIError<number, Headers> {}

package/src/index.ts

@@ -0,0 +1,246 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { type Agent } from "./_shims/index.js";
+import * as Core from "./core.js";
+import * as Errors from "./error.js";
+import * as Pagination from "./pagination.js";
+import { type PageParams, PageResponse } from "./pagination.js";
+import * as Uploads from "./uploads.js";
+import * as API from "./resources/index.js";
+import { KeyCreateParams, KeyCreateResponse, Keys } from "./resources/keys.js";
+import {
+  Workspace,
+  WorkspaceGetOrCreateParams,
+  WorkspaceListParams,
+  WorkspaceSearchParams,
+  WorkspaceUpdateParams,
+  Workspaces,
+  WorkspacesPage,
+} from "./resources/workspaces/workspaces.js";
+
+const environments = {
+  demo: 'https://demo.honcho.dev',
+  local: 'http://localhost:8000',
+  production: 'https://api.honcho.dev',
+};
+type Environment = keyof typeof environments;
+
+export interface ClientOptions {
+  /**
+   * Defaults to process.env['HONCHO_API_KEY'].
+   */
+  apiKey?: string | null | undefined;
+
+  /**
+   * Specifies the environment to use for the API.
+   *
+   * Each environment maps to a different base URL:
+   * - `demo` corresponds to `https://demo.honcho.dev`
+   * - `local` corresponds to `http://localhost:8000`
+   * - `production` corresponds to `https://api.honcho.dev`
+   */
+  environment?: Environment | undefined;
+
+  /**
+   * Override the default base URL for the API, e.g., "https://api.example.com/v2/"
+   *
+   * Defaults to process.env['HONCHO_BASE_URL'].
+   */
+  baseURL?: string | null | undefined;
+
+  /**
+   * The maximum amount of time (in milliseconds) that the client should wait for a response
+   * from the server before timing out a single request.
+   *
+   * Note that request timeouts are retried by default, so in a worst-case scenario you may wait
+   * much longer than this timeout before the promise succeeds or fails.
+   */
+  timeout?: number | undefined;
+
+  /**
+   * An HTTP agent used to manage HTTP(S) connections.
+   *
+   * If not provided, an agent will be constructed by default in the Node.js environment,
+   * otherwise no agent is used.
+   */
+  httpAgent?: Agent | undefined;
+
+  /**
+   * Specify a custom `fetch` function implementation.
+   *
+   * If not provided, we use `node-fetch` on Node.js and otherwise expect that `fetch` is
+   * defined globally.
+   */
+  fetch?: Core.Fetch | undefined;
+
+  /**
+   * The maximum number of times that the client will retry a request in case of a
+   * temporary failure, like a network error or a 5XX error from the server.
+   *
+   * @default 2
+   */
+  maxRetries?: number | undefined;
+
+  /**
+   * Default headers to include with every request to the API.
+   *
+   * These can be removed in individual requests by explicitly setting the
+   * header to `undefined` or `null` in request options.
+   */
+  defaultHeaders?: Core.Headers | undefined;
+
+  /**
+   * Default query parameters to include with every request to the API.
+   *
+   * These can be removed in individual requests by explicitly setting the
+   * param to `undefined` in request options.
+   */
+  defaultQuery?: Core.DefaultQuery | undefined;
+}
+
+/**
+ * API Client for interfacing with the Honcho API.
+ */
+export class Honcho extends Core.APIClient {
+  apiKey: string | null;
+
+  private _options: ClientOptions;
+
+  /**
+   * API Client for interfacing with the Honcho API.
+   *
+   * @param {string | null | undefined} [opts.apiKey=process.env['HONCHO_API_KEY'] ?? null]
+   * @param {Environment} [opts.environment=demo] - Specifies the environment URL to use for the API.
+   * @param {string} [opts.baseURL=process.env['HONCHO_BASE_URL'] ?? https://demo.honcho.dev] - Override the default base URL for the API.
+   * @param {number} [opts.timeout=1 minute] - The maximum amount of time (in milliseconds) the client will wait for a response before timing out.
+   * @param {number} [opts.httpAgent] - An HTTP agent used to manage HTTP(s) connections.
+   * @param {Core.Fetch} [opts.fetch] - Specify a custom `fetch` function implementation.
+   * @param {number} [opts.maxRetries=2] - The maximum number of times the client will retry a request.
+   * @param {Core.Headers} opts.defaultHeaders - Default headers to include with every request to the API.
+   * @param {Core.DefaultQuery} opts.defaultQuery - Default query parameters to include with every request to the API.
+   */
+  constructor({
+    baseURL = Core.readEnv('HONCHO_BASE_URL'),
+    apiKey = Core.readEnv('HONCHO_API_KEY') ?? null,
+    ...opts
+  }: ClientOptions = {}) {
+    const options: ClientOptions = {
+      apiKey,
+      ...opts,
+      baseURL,
+      environment: opts.environment ?? 'demo',
+    };
+
+    if (baseURL && opts.environment) {
+      throw new Errors.HonchoError(
+        'Ambiguous URL; The `baseURL` option (or HONCHO_BASE_URL env var) and the `environment` option are given. If you want to use the environment you must pass baseURL: null',
+      );
+    }
+
+    super({
+      baseURL: options.baseURL || environments[options.environment || 'demo'],
+      baseURLOverridden: baseURL ? baseURL !== environments[options.environment || 'demo'] : false,
+      timeout: options.timeout ?? 60000 /* 1 minute */,
+      httpAgent: options.httpAgent,
+      maxRetries: options.maxRetries,
+      fetch: options.fetch,
+    });
+
+    this._options = options;
+
+    this.apiKey = apiKey;
+  }
+
+  workspaces: API.Workspaces = new API.Workspaces(this);
+  keys: API.Keys = new API.Keys(this);
+
+  /**
+   * Check whether the base URL is set to its default.
+   */
+  #baseURLOverridden(): boolean {
+    return this.baseURL !== environments[this._options.environment || 'demo'];
+  }
+
+  protected override defaultQuery(): Core.DefaultQuery | undefined {
+    return this._options.defaultQuery;
+  }
+
+  protected override defaultHeaders(opts: Core.FinalRequestOptions): Core.Headers {
+    return {
+      ...super.defaultHeaders(opts),
+      ...this._options.defaultHeaders,
+    };
+  }
+
+  protected override authHeaders(opts: Core.FinalRequestOptions): Core.Headers {
+    if (this.apiKey == null) {
+      return {};
+    }
+    return { Authorization: `Bearer ${this.apiKey}` };
+  }
+
+  static Honcho = this;
+  static DEFAULT_TIMEOUT = 60000; // 1 minute
+
+  static HonchoError = Errors.HonchoError;
+  static APIError = Errors.APIError;
+  static APIConnectionError = Errors.APIConnectionError;
+  static APIConnectionTimeoutError = Errors.APIConnectionTimeoutError;
+  static APIUserAbortError = Errors.APIUserAbortError;
+  static NotFoundError = Errors.NotFoundError;
+  static ConflictError = Errors.ConflictError;
+  static RateLimitError = Errors.RateLimitError;
+  static BadRequestError = Errors.BadRequestError;
+  static AuthenticationError = Errors.AuthenticationError;
+  static InternalServerError = Errors.InternalServerError;
+  static PermissionDeniedError = Errors.PermissionDeniedError;
+  static UnprocessableEntityError = Errors.UnprocessableEntityError;
+
+  static toFile = Uploads.toFile;
+  static fileFromPath = Uploads.fileFromPath;
+}
+
+Honcho.Workspaces = Workspaces;
+Honcho.WorkspacesPage = WorkspacesPage;
+Honcho.Keys = Keys;
+export declare namespace Honcho {
+  export type RequestOptions = Core.RequestOptions;
+
+  export import Page = Pagination.Page;
+  export { type PageParams as PageParams, type PageResponse as PageResponse };
+
+  export {
+    Workspaces as Workspaces,
+    type Workspace as Workspace,
+    WorkspacesPage as WorkspacesPage,
+    type WorkspaceUpdateParams as WorkspaceUpdateParams,
+    type WorkspaceListParams as WorkspaceListParams,
+    type WorkspaceGetOrCreateParams as WorkspaceGetOrCreateParams,
+    type WorkspaceSearchParams as WorkspaceSearchParams,
+  };
+
+  export {
+    Keys as Keys,
+    type KeyCreateResponse as KeyCreateResponse,
+    type KeyCreateParams as KeyCreateParams,
+  };
+}
+
+export { toFile, fileFromPath } from "./uploads.js";
+export {
+  HonchoError,
+  APIError,
+  APIConnectionError,
+  APIConnectionTimeoutError,
+  APIUserAbortError,
+  NotFoundError,
+  ConflictError,
+  RateLimitError,
+  BadRequestError,
+  AuthenticationError,
+  InternalServerError,
+  PermissionDeniedError,
+  UnprocessableEntityError,
+} from "./error.js";
+
+export default Honcho;

package/src/lib/.keep

@@ -0,0 +1,4 @@
+File generated from our OpenAPI spec by Stainless.
+
+This directory can be used to store custom files to expand the SDK.
+It is ignored by Stainless code generation and its content (other than this keep file) won't be touched.

package/src/pagination.ts

@@ -0,0 +1,73 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { AbstractPage, Response, APIClient, FinalRequestOptions, PageInfo } from "./core.js";
+
+export interface PageResponse<Item> {
+  total: number;
+
+  items: Array<Item>;
+
+  page: number;
+
+  size: number;
+
+  pages: number;
+}
+
+export interface PageParams {
+  /**
+   * The page number
+   */
+  page?: number;
+
+  /**
+   * The number of items in a page
+   */
+  size?: number;
+}
+
+export class Page<Item> extends AbstractPage<Item> implements PageResponse<Item> {
+  total: number;
+
+  items: Array<Item>;
+
+  page: number;
+
+  size: number;
+
+  pages: number;
+
+  constructor(client: APIClient, response: Response, body: PageResponse<Item>, options: FinalRequestOptions) {
+    super(client, response, body, options);
+
+    this.total = body.total || 0;
+    this.items = body.items || [];
+    this.page = body.page || 0;
+    this.size = body.size || 0;
+    this.pages = body.pages || 0;
+  }
+
+  getPaginatedItems(): Item[] {
+    return this.items ?? [];
+  }
+
+  // @deprecated Please use `nextPageInfo()` instead
+  nextPageParams(): Partial<PageParams> | null {
+    const info = this.nextPageInfo();
+    if (!info) return null;
+    if ('params' in info) return info.params;
+    const params = Object.fromEntries(info.url.searchParams);
+    if (!Object.keys(params).length) return null;
+    return params;
+  }
+
+  nextPageInfo(): PageInfo | null {
+    const currentPage = this.page;
+
+    if (currentPage >= this.pages) {
+      return null;
+    }
+
+    return { params: { page: currentPage + 1 } };
+  }
+}

package/src/resource.ts

@@ -0,0 +1,11 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import type { Honcho } from "./index.js";
+
+export abstract class APIResource {
+  protected _client: Honcho;
+
+  constructor(client: Honcho) {
+    this._client = client;
+  }
+}

package/src/resources/index.ts

@@ -0,0 +1,12 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export { Keys, type KeyCreateResponse, type KeyCreateParams } from "./keys.js";
+export {
+  WorkspacesPage,
+  Workspaces,
+  type Workspace,
+  type WorkspaceUpdateParams,
+  type WorkspaceListParams,
+  type WorkspaceGetOrCreateParams,
+  type WorkspaceSearchParams,
+} from "./workspaces/workspaces.js";

package/src/resources/keys.ts

@@ -0,0 +1,51 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from "../resource.js";
+import { isRequestOptions } from "../core.js";
+import * as Core from "../core.js";
+
+export class Keys extends APIResource {
+  /**
+   * Create a new Key
+   */
+  create(params?: KeyCreateParams, options?: Core.RequestOptions): Core.APIPromise<unknown>;
+  create(options?: Core.RequestOptions): Core.APIPromise<unknown>;
+  create(
+    params: KeyCreateParams | Core.RequestOptions = {},
+    options?: Core.RequestOptions,
+  ): Core.APIPromise<unknown> {
+    if (isRequestOptions(params)) {
+      return this.create({}, params);
+    }
+    const { expires_at, peer_id, session_id, workspace_id } = params;
+    return this._client.post('/v1/keys', {
+      query: { expires_at, peer_id, session_id, workspace_id },
+      ...options,
+    });
+  }
+}
+
+export type KeyCreateResponse = unknown;
+
+export interface KeyCreateParams {
+  expires_at?: string | null;
+
+  /**
+   * ID of the peer to scope the key to
+   */
+  peer_id?: string | null;
+
+  /**
+   * ID of the session to scope the key to
+   */
+  session_id?: string | null;
+
+  /**
+   * ID of the workspace to scope the key to
+   */
+  workspace_id?: string | null;
+}
+
+export declare namespace Keys {
+  export { type KeyCreateResponse as KeyCreateResponse, type KeyCreateParams as KeyCreateParams };
+}

package/src/resources/workspaces/index.ts

@@ -0,0 +1,39 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export {
+  PeersPage,
+  Peers,
+  type PageSession,
+  type Peer,
+  type SessionGet,
+  type PeerChatResponse,
+  type PeerWorkingRepresentationResponse,
+  type PeerUpdateParams,
+  type PeerListParams,
+  type PeerChatParams,
+  type PeerGetOrCreateParams,
+  type PeerSearchParams,
+  type PeerWorkingRepresentationParams,
+} from "./peers/index.js";
+export {
+  SessionsPage,
+  Sessions,
+  type Session,
+  type SessionDeleteResponse,
+  type SessionGetContextResponse,
+  type SessionUpdateParams,
+  type SessionListParams,
+  type SessionCloneParams,
+  type SessionGetContextParams,
+  type SessionGetOrCreateParams,
+  type SessionSearchParams,
+} from "./sessions/index.js";
+export {
+  WorkspacesPage,
+  Workspaces,
+  type Workspace,
+  type WorkspaceUpdateParams,
+  type WorkspaceListParams,
+  type WorkspaceGetOrCreateParams,
+  type WorkspaceSearchParams,
+} from "./workspaces.js";

package/src/resources/workspaces/peers/index.ts

@@ -0,0 +1,24 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export {
+  Messages,
+  type MessageCreateResponse,
+  type MessageCreateParams,
+  type MessageListParams,
+} from "./messages.js";
+export {
+  PeersPage,
+  Peers,
+  type PageSession,
+  type Peer,
+  type SessionGet,
+  type PeerChatResponse,
+  type PeerWorkingRepresentationResponse,
+  type PeerUpdateParams,
+  type PeerListParams,
+  type PeerChatParams,
+  type PeerGetOrCreateParams,
+  type PeerSearchParams,
+  type PeerWorkingRepresentationParams,
+} from "./peers.js";
+export { Sessions, type SessionListParams } from "./sessions.js";

package/src/resources/workspaces/peers/messages.ts

@@ -0,0 +1,81 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from "../../../resource.js";
+import { isRequestOptions } from "../../../core.js";
+import * as Core from "../../../core.js";
+import * as SessionsMessagesAPI from "../sessions/messages.js";
+import { MessagesPage } from "../sessions/messages.js";
+import { type PageParams } from "../../../pagination.js";
+
+export class Messages extends APIResource {
+  /**
+   * Create messages for a peer
+   */
+  create(
+    workspaceId: string,
+    peerId: string,
+    body: MessageCreateParams,
+    options?: Core.RequestOptions,
+  ): Core.APIPromise<MessageCreateResponse> {
+    return this._client.post(`/v1/workspaces/${workspaceId}/peers/${peerId}/messages`, { body, ...options });
+  }
+
+  /**
+   * Get all messages for a peer
+   */
+  list(
+    workspaceId: string,
+    peerId: string,
+    params?: MessageListParams,
+    options?: Core.RequestOptions,
+  ): Core.PagePromise<MessagesPage, SessionsMessagesAPI.Message>;
+  list(
+    workspaceId: string,
+    peerId: string,
+    options?: Core.RequestOptions,
+  ): Core.PagePromise<MessagesPage, SessionsMessagesAPI.Message>;
+  list(
+    workspaceId: string,
+    peerId: string,
+    params: MessageListParams | Core.RequestOptions = {},
+    options?: Core.RequestOptions,
+  ): Core.PagePromise<MessagesPage, SessionsMessagesAPI.Message> {
+    if (isRequestOptions(params)) {
+      return this.list(workspaceId, peerId, {}, params);
+    }
+    const { page, reverse, size, ...body } = params;
+    return this._client.getAPIList(
+      `/v1/workspaces/${workspaceId}/peers/${peerId}/messages/list`,
+      MessagesPage,
+      { query: { page, reverse, size }, body, method: 'post', ...options },
+    );
+  }
+}
+
+export type MessageCreateResponse = Array<SessionsMessagesAPI.Message>;
+
+export interface MessageCreateParams {
+  messages: Array<SessionsMessagesAPI.MessageCreate>;
+}
+
+export interface MessageListParams extends PageParams {
+  /**
+   * Query param: Whether to reverse the order of results
+   */
+  reverse?: boolean | null;
+
+  /**
+   * Body param:
+   */
+  filter?: Record<string, unknown> | null;
+}
+
+export declare namespace Messages {
+  export {
+    type MessageCreateResponse as MessageCreateResponse,
+    type MessageCreateParams as MessageCreateParams,
+    type MessageListParams as MessageListParams,
+  };
+}
+
+export { MessagesPage };