@depup/ai 6.0.116-depup.0

package/src/ui/http-chat-transport.ts

@@ -0,0 +1,284 @@
+import {
+  FetchFunction,
+  Resolvable,
+  normalizeHeaders,
+  resolve,
+  withUserAgentSuffix,
+  getRuntimeEnvironmentUserAgent,
+} from '@ai-sdk/provider-utils';
+import { UIMessageChunk } from '../ui-message-stream/ui-message-chunks';
+import { ChatTransport } from './chat-transport';
+import { UIMessage } from './ui-messages';
+import { VERSION } from '../version';
+
+export type PrepareSendMessagesRequest<UI_MESSAGE extends UIMessage> = (
+  options: {
+    id: string;
+    messages: UI_MESSAGE[];
+    requestMetadata: unknown;
+    body: Record<string, any> | undefined;
+    credentials: RequestCredentials | undefined;
+    headers: HeadersInit | undefined;
+    api: string;
+  } & {
+    trigger: 'submit-message' | 'regenerate-message';
+    messageId: string | undefined;
+  },
+) =>
+  | {
+      body: object;
+      headers?: HeadersInit;
+      credentials?: RequestCredentials;
+      api?: string;
+    }
+  | PromiseLike<{
+      body: object;
+      headers?: HeadersInit;
+      credentials?: RequestCredentials;
+      api?: string;
+    }>;
+
+export type PrepareReconnectToStreamRequest = (options: {
+  id: string;
+  requestMetadata: unknown;
+  body: Record<string, any> | undefined;
+  credentials: RequestCredentials | undefined;
+  headers: HeadersInit | undefined;
+  api: string;
+}) =>
+  | {
+      headers?: HeadersInit;
+      credentials?: RequestCredentials;
+      api?: string;
+    }
+  | PromiseLike<{
+      headers?: HeadersInit;
+      credentials?: RequestCredentials;
+      api?: string;
+    }>;
+
+/**
+ * Options for the `HttpChatTransport` class.
+ *
+ * @param UI_MESSAGE - The type of message to be used in the chat.
+ */
+export type HttpChatTransportInitOptions<UI_MESSAGE extends UIMessage> = {
+  /**
+   * The API URL to be used for the chat transport.
+   * Defaults to '/api/chat'.
+   */
+  api?: string;
+
+  /**
+   * The credentials mode to be used for the fetch request.
+   * Possible values are: 'omit', 'same-origin', 'include'.
+   * Defaults to 'same-origin'.
+   */
+  credentials?: Resolvable<RequestCredentials>;
+
+  /**
+   * HTTP headers to be sent with the API request.
+   */
+  headers?: Resolvable<Record<string, string> | Headers>;
+
+  /**
+   * Extra body object to be sent with the API request.
+   * @example
+   * Send a `sessionId` to the API along with the messages.
+   * ```js
+   * useChat({
+   *   body: {
+   *     sessionId: '123',
+   *   }
+   * })
+   * ```
+   */
+  body?: Resolvable<object>;
+
+  /**
+   * Custom fetch implementation. You can use it as a middleware to intercept requests,
+   * or to provide a custom fetch implementation for e.g. testing.
+   */
+  fetch?: FetchFunction;
+
+  /**
+   * When a function is provided, it will be used
+   * to prepare the request body for the chat API. This can be useful for
+   * customizing the request body based on the messages and data in the chat.
+   */
+  prepareSendMessagesRequest?: PrepareSendMessagesRequest<UI_MESSAGE>;
+
+  /**
+   * When a function is provided, it will be used
+   * to prepare the reconnect request for the chat API. This can be useful for
+   * customizing the request based on the chat session.
+   */
+  prepareReconnectToStreamRequest?: PrepareReconnectToStreamRequest;
+};
+
+export abstract class HttpChatTransport<UI_MESSAGE extends UIMessage>
+  implements ChatTransport<UI_MESSAGE>
+{
+  protected api: string;
+  protected credentials: HttpChatTransportInitOptions<UI_MESSAGE>['credentials'];
+  protected headers: HttpChatTransportInitOptions<UI_MESSAGE>['headers'];
+  protected body: HttpChatTransportInitOptions<UI_MESSAGE>['body'];
+  protected fetch?: FetchFunction;
+  protected prepareSendMessagesRequest?: PrepareSendMessagesRequest<UI_MESSAGE>;
+  protected prepareReconnectToStreamRequest?: PrepareReconnectToStreamRequest;
+
+  constructor({
+    api = '/api/chat',
+    credentials,
+    headers,
+    body,
+    fetch,
+    prepareSendMessagesRequest,
+    prepareReconnectToStreamRequest,
+  }: HttpChatTransportInitOptions<UI_MESSAGE>) {
+    this.api = api;
+    this.credentials = credentials;
+    this.headers = headers;
+    this.body = body;
+    this.fetch = fetch;
+    this.prepareSendMessagesRequest = prepareSendMessagesRequest;
+    this.prepareReconnectToStreamRequest = prepareReconnectToStreamRequest;
+  }
+
+  async sendMessages({
+    abortSignal,
+    ...options
+  }: Parameters<ChatTransport<UI_MESSAGE>['sendMessages']>[0]) {
+    const resolvedBody = await resolve(this.body);
+    const resolvedHeaders = await resolve(this.headers);
+    const resolvedCredentials = await resolve(this.credentials);
+
+    const baseHeaders = {
+      ...normalizeHeaders(resolvedHeaders),
+      ...normalizeHeaders(options.headers),
+    };
+
+    const preparedRequest = await this.prepareSendMessagesRequest?.({
+      api: this.api,
+      id: options.chatId,
+      messages: options.messages,
+      body: { ...resolvedBody, ...options.body },
+      headers: baseHeaders,
+      credentials: resolvedCredentials,
+      requestMetadata: options.metadata,
+      trigger: options.trigger,
+      messageId: options.messageId,
+    });
+
+    const api = preparedRequest?.api ?? this.api;
+    const headers =
+      preparedRequest?.headers !== undefined
+        ? normalizeHeaders(preparedRequest.headers)
+        : baseHeaders;
+    const body =
+      preparedRequest?.body !== undefined
+        ? preparedRequest.body
+        : {
+            ...resolvedBody,
+            ...options.body,
+            id: options.chatId,
+            messages: options.messages,
+            trigger: options.trigger,
+            messageId: options.messageId,
+          };
+    const credentials = preparedRequest?.credentials ?? resolvedCredentials;
+
+    // avoid caching globalThis.fetch in case it is patched by other libraries
+    const fetch = this.fetch ?? globalThis.fetch;
+
+    const response = await fetch(api, {
+      method: 'POST',
+      headers: withUserAgentSuffix(
+        {
+          'Content-Type': 'application/json',
+          ...headers,
+        },
+        `ai-sdk/${VERSION}`,
+        getRuntimeEnvironmentUserAgent(),
+      ),
+      body: JSON.stringify(body),
+      credentials,
+      signal: abortSignal,
+    });
+
+    if (!response.ok) {
+      throw new Error(
+        (await response.text()) ?? 'Failed to fetch the chat response.',
+      );
+    }
+
+    if (!response.body) {
+      throw new Error('The response body is empty.');
+    }
+
+    return this.processResponseStream(response.body);
+  }
+
+  async reconnectToStream(
+    options: Parameters<ChatTransport<UI_MESSAGE>['reconnectToStream']>[0],
+  ): Promise<ReadableStream<UIMessageChunk> | null> {
+    const resolvedBody = await resolve(this.body);
+    const resolvedHeaders = await resolve(this.headers);
+    const resolvedCredentials = await resolve(this.credentials);
+
+    const baseHeaders = {
+      ...normalizeHeaders(resolvedHeaders),
+      ...normalizeHeaders(options.headers),
+    };
+
+    const preparedRequest = await this.prepareReconnectToStreamRequest?.({
+      api: this.api,
+      id: options.chatId,
+      body: { ...resolvedBody, ...options.body },
+      headers: baseHeaders,
+      credentials: resolvedCredentials,
+      requestMetadata: options.metadata,
+    });
+
+    const api = preparedRequest?.api ?? `${this.api}/${options.chatId}/stream`;
+    const headers =
+      preparedRequest?.headers !== undefined
+        ? normalizeHeaders(preparedRequest.headers)
+        : baseHeaders;
+    const credentials = preparedRequest?.credentials ?? resolvedCredentials;
+
+    // avoid caching globalThis.fetch in case it is patched by other libraries
+    const fetch = this.fetch ?? globalThis.fetch;
+
+    const response = await fetch(api, {
+      method: 'GET',
+      headers: withUserAgentSuffix(
+        headers,
+        `ai-sdk/${VERSION}`,
+        getRuntimeEnvironmentUserAgent(),
+      ),
+      credentials,
+    });
+
+    // no active stream found, so we do not resume
+    if (response.status === 204) {
+      return null;
+    }
+
+    if (!response.ok) {
+      throw new Error(
+        (await response.text()) ?? 'Failed to fetch the chat response.',
+      );
+    }
+
+    if (!response.body) {
+      throw new Error('The response body is empty.');
+    }
+
+    return this.processResponseStream(response.body);
+  }
+
+  protected abstract processResponseStream(
+    stream: ReadableStream<Uint8Array<ArrayBufferLike>>,
+  ): ReadableStream<UIMessageChunk>;
+}

package/src/ui/index.ts

@@ -0,0 +1,71 @@
+export { callCompletionApi } from './call-completion-api';
+export {
+  AbstractChat,
+  type ChatAddToolApproveResponseFunction,
+  type ChatInit,
+  type ChatOnDataCallback,
+  type ChatOnErrorCallback,
+  type ChatOnFinishCallback,
+  type ChatOnToolCallCallback,
+  type ChatRequestOptions,
+  type ChatState,
+  type ChatStatus,
+  type CreateUIMessage,
+  type InferUIDataParts,
+  type UIDataPartSchemas,
+} from './chat';
+export { type ChatTransport } from './chat-transport';
+export { convertFileListToFileUIParts } from './convert-file-list-to-file-ui-parts';
+export { convertToModelMessages } from './convert-to-model-messages';
+export { DefaultChatTransport } from './default-chat-transport';
+export {
+  DirectChatTransport,
+  type DirectChatTransportOptions,
+} from './direct-chat-transport';
+export {
+  HttpChatTransport,
+  type HttpChatTransportInitOptions,
+  type PrepareReconnectToStreamRequest,
+  type PrepareSendMessagesRequest,
+} from './http-chat-transport';
+export { lastAssistantMessageIsCompleteWithApprovalResponses } from './last-assistant-message-is-complete-with-approval-responses';
+export { lastAssistantMessageIsCompleteWithToolCalls } from './last-assistant-message-is-complete-with-tool-calls';
+export { TextStreamChatTransport } from './text-stream-chat-transport';
+export {
+  getStaticToolName,
+  getToolName,
+  getToolOrDynamicToolName,
+  isDataUIPart,
+  isFileUIPart,
+  isReasoningUIPart,
+  isStaticToolUIPart,
+  isTextUIPart,
+  isToolOrDynamicToolUIPart,
+  isToolUIPart,
+  type DataUIPart,
+  type DynamicToolUIPart,
+  type FileUIPart,
+  type InferUITool,
+  type InferUITools,
+  type ReasoningUIPart,
+  type SourceDocumentUIPart,
+  type SourceUrlUIPart,
+  type StepStartUIPart,
+  type TextUIPart,
+  type ToolUIPart,
+  type UIDataTypes,
+  type UIMessage,
+  type UIMessagePart,
+  type UITool,
+  type UIToolInvocation,
+  type UITools,
+} from './ui-messages';
+export {
+  type CompletionRequestOptions,
+  type UseCompletionOptions,
+} from './use-completion';
+export {
+  safeValidateUIMessages,
+  validateUIMessages,
+  type SafeValidateUIMessagesResult,
+} from './validate-ui-messages';

package/src/ui/last-assistant-message-is-complete-with-approval-responses.ts

@@ -0,0 +1,44 @@
+import { isToolUIPart, type UIMessage } from './ui-messages';
+
+/**
+ * Check if the last message is an assistant message with completed tool call approvals.
+ * The last step of the message must have at least one tool approval response and
+ * all tool approvals must have a response.
+ */
+export function lastAssistantMessageIsCompleteWithApprovalResponses({
+  messages,
+}: {
+  messages: UIMessage[];
+}): boolean {
+  const message = messages[messages.length - 1];
+
+  if (!message) {
+    return false;
+  }
+
+  if (message.role !== 'assistant') {
+    return false;
+  }
+
+  const lastStepStartIndex = message.parts.reduce((lastIndex, part, index) => {
+    return part.type === 'step-start' ? index : lastIndex;
+  }, -1);
+
+  const lastStepToolInvocations = message.parts
+    .slice(lastStepStartIndex + 1)
+    .filter(isToolUIPart)
+    .filter(part => !part.providerExecuted);
+
+  return (
+    // has at least one tool approval response
+    lastStepToolInvocations.filter(part => part.state === 'approval-responded')
+      .length > 0 &&
+    // all tool approvals must have a response
+    lastStepToolInvocations.every(
+      part =>
+        part.state === 'output-available' ||
+        part.state === 'output-error' ||
+        part.state === 'approval-responded',
+    )
+  );
+}

package/src/ui/last-assistant-message-is-complete-with-tool-calls.ts

@@ -0,0 +1,39 @@
+import { isToolUIPart, type UIMessage } from './ui-messages';
+
+/**
+ * Check if the last message is an assistant message with completed tool calls.
+ * The last step of the message must have at least one tool invocation and
+ * all tool invocations must have a result.
+ */
+export function lastAssistantMessageIsCompleteWithToolCalls({
+  messages,
+}: {
+  messages: UIMessage[];
+}): boolean {
+  const message = messages[messages.length - 1];
+
+  if (!message) {
+    return false;
+  }
+
+  if (message.role !== 'assistant') {
+    return false;
+  }
+
+  const lastStepStartIndex = message.parts.reduce((lastIndex, part, index) => {
+    return part.type === 'step-start' ? index : lastIndex;
+  }, -1);
+
+  const lastStepToolInvocations = message.parts
+    .slice(lastStepStartIndex + 1)
+    .filter(isToolUIPart)
+    .filter(part => !part.providerExecuted);
+
+  return (
+    lastStepToolInvocations.length > 0 &&
+    lastStepToolInvocations.every(
+      part =>
+        part.state === 'output-available' || part.state === 'output-error',
+    )
+  );
+}

package/src/ui/process-text-stream.ts

@@ -0,0 +1,16 @@
+export async function processTextStream({
+  stream,
+  onTextPart,
+}: {
+  stream: ReadableStream<Uint8Array>;
+  onTextPart: (chunk: string) => Promise<void> | void;
+}): Promise<void> {
+  const reader = stream.pipeThrough(new TextDecoderStream()).getReader();
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) {
+      break;
+    }
+    await onTextPart(value);
+  }
+}