@tambo-ai/typescript-sdk 0.31.0

package/src/resources/beta/threads/threads.ts

@@ -0,0 +1,379 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../../resource';
+import { isRequestOptions } from '../../../core';
+import * as Core from '../../../core';
+import * as ThreadsAPI from './threads';
+import * as Shared from '../../shared';
+import * as MessagesAPI from './messages';
+import {
+  MessageCreateParams,
+  MessageListParams,
+  MessageListResponse,
+  MessageUpdateComponentStateParams,
+  Messages,
+} from './messages';
+import * as SuggestionsAPI from './suggestions';
+import {
+  Suggestion,
+  SuggestionGenerateParams,
+  SuggestionGenerateResponse,
+  SuggestionListResponse,
+  Suggestions,
+  SuggestionsGenerate,
+} from './suggestions';
+import { OffsetAndLimit, type OffsetAndLimitParams } from '../../../pagination';
+
+export class Threads extends APIResource {
+  messages: MessagesAPI.Messages = new MessagesAPI.Messages(this._client);
+  suggestions: SuggestionsAPI.Suggestions = new SuggestionsAPI.Suggestions(this._client);
+
+  create(body: ThreadCreateParams, options?: Core.RequestOptions): Core.APIPromise<Thread> {
+    return this._client.post('/threads', { body, ...options });
+  }
+
+  retrieve(id: string, options?: Core.RequestOptions): Core.APIPromise<ThreadRetrieveResponse> {
+    return this._client.get(`/threads/${id}`, options);
+  }
+
+  update(id: string, body: ThreadUpdateParams, options?: Core.RequestOptions): Core.APIPromise<Thread> {
+    return this._client.put(`/threads/${id}`, { body, ...options });
+  }
+
+  list(
+    projectId: string,
+    query?: ThreadListParams,
+    options?: Core.RequestOptions,
+  ): Core.PagePromise<ThreadsOffsetAndLimit, Thread>;
+  list(projectId: string, options?: Core.RequestOptions): Core.PagePromise<ThreadsOffsetAndLimit, Thread>;
+  list(
+    projectId: string,
+    query: ThreadListParams | Core.RequestOptions = {},
+    options?: Core.RequestOptions,
+  ): Core.PagePromise<ThreadsOffsetAndLimit, Thread> {
+    if (isRequestOptions(query)) {
+      return this.list(projectId, {}, query);
+    }
+    return this._client.getAPIList(`/threads/project/${projectId}`, ThreadsOffsetAndLimit, {
+      query,
+      ...options,
+    });
+  }
+
+  delete(id: string, options?: Core.RequestOptions): Core.APIPromise<void> {
+    return this._client.delete(`/threads/${id}`, {
+      ...options,
+      headers: { Accept: '*/*', ...options?.headers },
+    });
+  }
+
+  advance(body: ThreadAdvanceParams, options?: Core.RequestOptions): Core.APIPromise<ThreadAdvanceResponse> {
+    return this._client.post('/threads/advance', { body, ...options });
+  }
+
+  advanceById(
+    id: string,
+    body: ThreadAdvanceByIDParams,
+    options?: Core.RequestOptions,
+  ): Core.APIPromise<ThreadAdvanceByIDResponse> {
+    return this._client.post(`/threads/${id}/advance`, { body, ...options });
+  }
+}
+
+export class ThreadsOffsetAndLimit extends OffsetAndLimit<Thread> {}
+
+export interface ChatCompletionContentPart {
+  type: 'text' | 'image_url' | 'input_audio';
+
+  image_url?: ChatCompletionContentPart.ImageURL;
+
+  input_audio?: ChatCompletionContentPart.InputAudio;
+
+  text?: string;
+}
+
+export namespace ChatCompletionContentPart {
+  export interface ImageURL {
+    url: string;
+
+    detail?: 'auto' | 'high' | 'low';
+  }
+
+  export interface InputAudio {
+    data: string;
+
+    format: 'wav' | 'mp3';
+  }
+}
+
+export interface Thread {
+  id: string;
+
+  createdAt: string;
+
+  projectId: string;
+
+  updatedAt: string;
+
+  contextKey?: string;
+
+  generationStage?:
+    | 'IDLE'
+    | 'CHOOSING_COMPONENT'
+    | 'FETCHING_CONTEXT'
+    | 'HYDRATING_COMPONENT'
+    | 'STREAMING_RESPONSE'
+    | 'COMPLETE'
+    | 'ERROR';
+
+  metadata?: Record<string, unknown>;
+
+  statusMessage?: string;
+}
+
+export interface ThreadMessage {
+  id: string;
+
+  content: Array<ChatCompletionContentPart>;
+
+  createdAt: string;
+
+  role: 'user' | 'assistant' | 'system' | 'tool' | 'hydra';
+
+  threadId: string;
+
+  actionType?: 'tool_call' | 'tool_response';
+
+  component?: ThreadMessage.Component;
+
+  componentState?: Record<string, unknown>;
+
+  metadata?: Record<string, unknown>;
+
+  tool_calls?: Array<unknown>;
+
+  toolCallRequest?: Shared.ToolCallRequest;
+}
+
+export namespace ThreadMessage {
+  export interface Component {
+    componentName: string | null;
+
+    message: string;
+
+    props: Record<string, unknown>;
+  }
+}
+
+export interface ThreadRetrieveResponse {
+  id: string;
+
+  createdAt: string;
+
+  messages: Array<ThreadMessage>;
+
+  projectId: string;
+
+  updatedAt: string;
+
+  contextKey?: string;
+
+  generationStage?:
+    | 'IDLE'
+    | 'CHOOSING_COMPONENT'
+    | 'FETCHING_CONTEXT'
+    | 'HYDRATING_COMPONENT'
+    | 'STREAMING_RESPONSE'
+    | 'COMPLETE'
+    | 'ERROR';
+
+  metadata?: Record<string, unknown>;
+
+  statusMessage?: string;
+}
+
+export interface ThreadAdvanceResponse {
+  generationStage:
+    | 'IDLE'
+    | 'CHOOSING_COMPONENT'
+    | 'FETCHING_CONTEXT'
+    | 'HYDRATING_COMPONENT'
+    | 'STREAMING_RESPONSE'
+    | 'COMPLETE'
+    | 'ERROR';
+
+  responseMessageDto: ThreadMessage;
+
+  statusMessage?: string;
+}
+
+export interface ThreadAdvanceByIDResponse {
+  generationStage:
+    | 'IDLE'
+    | 'CHOOSING_COMPONENT'
+    | 'FETCHING_CONTEXT'
+    | 'HYDRATING_COMPONENT'
+    | 'STREAMING_RESPONSE'
+    | 'COMPLETE'
+    | 'ERROR';
+
+  responseMessageDto: ThreadMessage;
+
+  statusMessage?: string;
+}
+
+export interface ThreadCreateParams {
+  projectId: string;
+
+  contextKey?: string;
+
+  generationStage?:
+    | 'IDLE'
+    | 'CHOOSING_COMPONENT'
+    | 'FETCHING_CONTEXT'
+    | 'HYDRATING_COMPONENT'
+    | 'STREAMING_RESPONSE'
+    | 'COMPLETE'
+    | 'ERROR';
+
+  metadata?: Record<string, unknown>;
+
+  statusMessage?: string;
+}
+
+export interface ThreadUpdateParams {
+  projectId: string;
+
+  contextKey?: string;
+
+  generationStage?:
+    | 'IDLE'
+    | 'CHOOSING_COMPONENT'
+    | 'FETCHING_CONTEXT'
+    | 'HYDRATING_COMPONENT'
+    | 'STREAMING_RESPONSE'
+    | 'COMPLETE'
+    | 'ERROR';
+
+  metadata?: Record<string, unknown>;
+
+  statusMessage?: string;
+}
+
+export interface ThreadListParams extends OffsetAndLimitParams {
+  contextKey?: string;
+}
+
+export interface ThreadAdvanceParams {
+  availableComponents?: Array<Shared.AvailableComponent>;
+
+  contextKey?: string;
+
+  messageToAppend?: ThreadAdvanceParams.MessageToAppend;
+}
+
+export namespace ThreadAdvanceParams {
+  export interface MessageToAppend {
+    content: Array<ThreadsAPI.ChatCompletionContentPart>;
+
+    role: 'user' | 'assistant' | 'system' | 'tool' | 'hydra';
+
+    actionType?: 'tool_call' | 'tool_response';
+
+    component?: MessageToAppend.Component;
+
+    metadata?: Record<string, unknown>;
+
+    tool_calls?: Array<unknown>;
+
+    toolCallRequest?: Shared.ToolCallRequest;
+
+    toolResponse?: unknown;
+  }
+
+  export namespace MessageToAppend {
+    export interface Component {
+      componentName: string | null;
+
+      message: string;
+
+      props: Record<string, unknown>;
+    }
+  }
+}
+
+export interface ThreadAdvanceByIDParams {
+  availableComponents?: Array<Shared.AvailableComponent>;
+
+  contextKey?: string;
+
+  messageToAppend?: ThreadAdvanceByIDParams.MessageToAppend;
+}
+
+export namespace ThreadAdvanceByIDParams {
+  export interface MessageToAppend {
+    content: Array<ThreadsAPI.ChatCompletionContentPart>;
+
+    role: 'user' | 'assistant' | 'system' | 'tool' | 'hydra';
+
+    actionType?: 'tool_call' | 'tool_response';
+
+    component?: MessageToAppend.Component;
+
+    metadata?: Record<string, unknown>;
+
+    tool_calls?: Array<unknown>;
+
+    toolCallRequest?: Shared.ToolCallRequest;
+
+    toolResponse?: unknown;
+  }
+
+  export namespace MessageToAppend {
+    export interface Component {
+      componentName: string | null;
+
+      message: string;
+
+      props: Record<string, unknown>;
+    }
+  }
+}
+
+Threads.ThreadsOffsetAndLimit = ThreadsOffsetAndLimit;
+Threads.Messages = Messages;
+Threads.Suggestions = Suggestions;
+
+export declare namespace Threads {
+  export {
+    type ChatCompletionContentPart as ChatCompletionContentPart,
+    type Thread as Thread,
+    type ThreadMessage as ThreadMessage,
+    type ThreadRetrieveResponse as ThreadRetrieveResponse,
+    type ThreadAdvanceResponse as ThreadAdvanceResponse,
+    type ThreadAdvanceByIDResponse as ThreadAdvanceByIDResponse,
+    ThreadsOffsetAndLimit as ThreadsOffsetAndLimit,
+    type ThreadCreateParams as ThreadCreateParams,
+    type ThreadUpdateParams as ThreadUpdateParams,
+    type ThreadListParams as ThreadListParams,
+    type ThreadAdvanceParams as ThreadAdvanceParams,
+    type ThreadAdvanceByIDParams as ThreadAdvanceByIDParams,
+  };
+
+  export {
+    Messages as Messages,
+    type MessageListResponse as MessageListResponse,
+    type MessageCreateParams as MessageCreateParams,
+    type MessageListParams as MessageListParams,
+    type MessageUpdateComponentStateParams as MessageUpdateComponentStateParams,
+  };
+
+  export {
+    Suggestions as Suggestions,
+    type Suggestion as Suggestion,
+    type SuggestionsGenerate as SuggestionsGenerate,
+    type SuggestionListResponse as SuggestionListResponse,
+    type SuggestionGenerateResponse as SuggestionGenerateResponse,
+    type SuggestionGenerateParams as SuggestionGenerateParams,
+  };
+}

package/src/resources/components.ts

@@ -0,0 +1,105 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../resource';
+import * as Core from '../core';
+import * as Shared from './shared';
+
+export class Components extends APIResource {
+  generate(
+    body: ComponentGenerateParams,
+    options?: Core.RequestOptions,
+  ): Core.APIPromise<ComponentGenerateResponse> {
+    return this._client.post('/components/generate', { body, ...options });
+  }
+
+  hydrate(
+    body: ComponentHydrateParams,
+    options?: Core.RequestOptions,
+  ): Core.APIPromise<ComponentHydrateResponse> {
+    return this._client.post('/components/hydrate', { body, ...options });
+  }
+}
+
+export interface LegacyChatMessage {
+  message: string;
+
+  sender: 'hydra' | 'user' | 'tool';
+
+  additionalContext?: string;
+}
+
+export interface ComponentGenerateResponse {
+  componentName: string | null;
+
+  message: string;
+
+  props: Record<string, unknown>;
+
+  threadId: string;
+
+  suggestedActions?: Array<ComponentGenerateResponse.SuggestedAction>;
+
+  toolCallRequest?: Shared.ToolCallRequest;
+}
+
+export namespace ComponentGenerateResponse {
+  export interface SuggestedAction {
+    actionText: string;
+
+    label: string;
+  }
+}
+
+export interface ComponentHydrateResponse {
+  componentName: string | null;
+
+  message: string;
+
+  props: Record<string, unknown>;
+
+  threadId: string;
+
+  suggestedActions?: Array<ComponentHydrateResponse.SuggestedAction>;
+
+  toolCallRequest?: Shared.ToolCallRequest;
+}
+
+export namespace ComponentHydrateResponse {
+  export interface SuggestedAction {
+    actionText: string;
+
+    label: string;
+  }
+}
+
+export interface ComponentGenerateParams {
+  availableComponents: Record<string, Shared.AvailableComponent>;
+
+  messageHistory: Array<LegacyChatMessage>;
+
+  contextKey?: string;
+
+  threadId?: string;
+}
+
+export interface ComponentHydrateParams {
+  component: Shared.AvailableComponent;
+
+  messageHistory: Array<LegacyChatMessage>;
+
+  contextKey?: string;
+
+  threadId?: string;
+
+  toolResponse?: unknown;
+}
+
+export declare namespace Components {
+  export {
+    type LegacyChatMessage as LegacyChatMessage,
+    type ComponentGenerateResponse as ComponentGenerateResponse,
+    type ComponentHydrateResponse as ComponentHydrateResponse,
+    type ComponentGenerateParams as ComponentGenerateParams,
+    type ComponentHydrateParams as ComponentHydrateParams,
+  };
+}

package/src/resources/index.ts

@@ -0,0 +1,12 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export * from './shared';
+export { Beta } from './beta/beta';
+export {
+  Components,
+  type LegacyChatMessage,
+  type ComponentGenerateResponse,
+  type ComponentHydrateResponse,
+  type ComponentGenerateParams,
+  type ComponentHydrateParams,
+} from './components';

package/src/resources/shared.ts

@@ -0,0 +1,59 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export interface AvailableComponent {
+  contextTools: Array<ComponentContextToolMetadata>;
+
+  description: string;
+
+  name: string;
+
+  props: Record<string, unknown>;
+}
+
+export interface ComponentContextToolMetadata {
+  description: string;
+
+  name: string;
+
+  parameters: Array<ToolParameters>;
+}
+
+export interface ToolCallRequest {
+  parameters: Array<ToolCallRequest.Parameter>;
+
+  toolName: string;
+
+  tool?: string;
+
+  toolCallId?: string;
+}
+
+export namespace ToolCallRequest {
+  export interface Parameter {
+    parameterName: string;
+
+    parameterValue: unknown;
+  }
+}
+
+export interface ToolParameters {
+  description: string;
+
+  isRequired: boolean;
+
+  name: string;
+
+  type: string;
+
+  enumValues?: Array<string>;
+
+  items?: ToolParameters.Items;
+
+  schema?: unknown;
+}
+
+export namespace ToolParameters {
+  export interface Items {
+    type: string;
+  }
+}

package/src/shims/node.ts

@@ -0,0 +1,50 @@
+// @ts-ignore
+import * as types from '../_shims/node-types';
+import { setShims } from '../_shims/registry';
+import { getRuntime } from '../_shims/node-runtime';
+setShims(getRuntime());
+
+declare module '../_shims/manual-types' {
+  export namespace manual {
+    // @ts-ignore
+    export type Agent = types.Agent;
+    // @ts-ignore
+    export import fetch = types.fetch;
+    // @ts-ignore
+    export type Request = types.Request;
+    // @ts-ignore
+    export type RequestInfo = types.RequestInfo;
+    // @ts-ignore
+    export type RequestInit = types.RequestInit;
+    // @ts-ignore
+    export type Response = types.Response;
+    // @ts-ignore
+    export type ResponseInit = types.ResponseInit;
+    // @ts-ignore
+    export type ResponseType = types.ResponseType;
+    // @ts-ignore
+    export type BodyInit = types.BodyInit;
+    // @ts-ignore
+    export type Headers = types.Headers;
+    // @ts-ignore
+    export type HeadersInit = types.HeadersInit;
+    // @ts-ignore
+    export type BlobPropertyBag = types.BlobPropertyBag;
+    // @ts-ignore
+    export type FilePropertyBag = types.FilePropertyBag;
+    // @ts-ignore
+    export type FileFromPathOptions = types.FileFromPathOptions;
+    // @ts-ignore
+    export import FormData = types.FormData;
+    // @ts-ignore
+    export import File = types.File;
+    // @ts-ignore
+    export import Blob = types.Blob;
+    // @ts-ignore
+    export type Readable = types.Readable;
+    // @ts-ignore
+    export type FsReadStream = types.FsReadStream;
+    // @ts-ignore
+    export import ReadableStream = types.ReadableStream;
+  }
+}

package/src/shims/web.ts

@@ -0,0 +1,50 @@
+// @ts-ignore
+import * as types from '../_shims/web-types';
+import { setShims } from '../_shims/registry';
+import { getRuntime } from '../_shims/web-runtime';
+setShims(getRuntime({ manuallyImported: true }));
+
+declare module '../_shims/manual-types' {
+  export namespace manual {
+    // @ts-ignore
+    export type Agent = types.Agent;
+    // @ts-ignore
+    export import fetch = types.fetch;
+    // @ts-ignore
+    export type Request = types.Request;
+    // @ts-ignore
+    export type RequestInfo = types.RequestInfo;
+    // @ts-ignore
+    export type RequestInit = types.RequestInit;
+    // @ts-ignore
+    export type Response = types.Response;
+    // @ts-ignore
+    export type ResponseInit = types.ResponseInit;
+    // @ts-ignore
+    export type ResponseType = types.ResponseType;
+    // @ts-ignore
+    export type BodyInit = types.BodyInit;
+    // @ts-ignore
+    export type Headers = types.Headers;
+    // @ts-ignore
+    export type HeadersInit = types.HeadersInit;
+    // @ts-ignore
+    export type BlobPropertyBag = types.BlobPropertyBag;
+    // @ts-ignore
+    export type FilePropertyBag = types.FilePropertyBag;
+    // @ts-ignore
+    export type FileFromPathOptions = types.FileFromPathOptions;
+    // @ts-ignore
+    export import FormData = types.FormData;
+    // @ts-ignore
+    export import File = types.File;
+    // @ts-ignore
+    export import Blob = types.Blob;
+    // @ts-ignore
+    export type Readable = types.Readable;
+    // @ts-ignore
+    export type FsReadStream = types.FsReadStream;
+    // @ts-ignore
+    export import ReadableStream = types.ReadableStream;
+  }
+}

package/src/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  // this config is included in the published src directory to prevent TS errors
+  // from appearing when users go to source, and VSCode opens the source .ts file
+  // via declaration maps
+  "include": [
+    "index.ts"
+  ],
+  "compilerOptions": {
+    "target": "es2020",
+    "lib": [
+      "DOM",
+      "ES2020"
+    ],
+    "moduleResolution": "node"
+  }
+}