@vibedeckx/win32-x64 0.1.16 → 0.1.19

package/node_modules/ai/src/ui/convert-file-list-to-file-ui-parts.ts

@@ -1,36 +0,0 @@
-import { FileUIPart } from './ui-messages';
-
-export async function convertFileListToFileUIParts(
-  files: FileList | undefined,
-): Promise<Array<FileUIPart>> {
-  if (files == null) {
-    return [];
-  }
-
-  // React-native doesn't have a FileList global:
-  if (!globalThis.FileList || !(files instanceof globalThis.FileList)) {
-    throw new Error('FileList is not supported in the current environment');
-  }
-
-  return Promise.all(
-    Array.from(files).map(async file => {
-      const { name, type } = file;
-
-      const dataUrl = await new Promise<string>((resolve, reject) => {
-        const reader = new FileReader();
-        reader.onload = readerEvent => {
-          resolve(readerEvent.target?.result as string);
-        };
-        reader.onerror = error => reject(error);
-        reader.readAsDataURL(file);
-      });
-
-      return {
-        type: 'file',
-        mediaType: type,
-        filename: name,
-        url: dataUrl,
-      };
-    }),
-  );
-}

package/node_modules/ai/src/ui/convert-to-model-messages.ts

@@ -1,379 +0,0 @@
-import {
-  AssistantContent,
-  FilePart,
-  isNonNullable,
-  ModelMessage,
-  TextPart,
-  ToolApprovalResponse,
-  ToolResultPart,
-} from '@ai-sdk/provider-utils';
-import { ToolSet } from '../generate-text/tool-set';
-import { createToolModelOutput } from '../prompt/create-tool-model-output';
-import { MessageConversionError } from '../prompt/message-conversion-error';
-import {
-  DataUIPart,
-  DynamicToolUIPart,
-  FileUIPart,
-  getToolName,
-  InferUIMessageData,
-  InferUIMessageTools,
-  isDataUIPart,
-  isFileUIPart,
-  isReasoningUIPart,
-  isTextUIPart,
-  isToolUIPart,
-  ReasoningUIPart,
-  TextUIPart,
-  ToolUIPart,
-  UIMessage,
-} from './ui-messages';
-
-/**
- * Converts an array of UI messages from useChat into an array of ModelMessages that can be used
- * with the AI functions (e.g. `streamText`, `generateText`).
- *
- * @param messages - The UI messages to convert.
- * @param options.tools - The tools to use.
- * @param options.ignoreIncompleteToolCalls - Whether to ignore incomplete tool calls. Default is `false`.
- * @param options.convertDataPart - Optional function to convert data parts to text or file model message parts. Returns `undefined` if the part should be ignored.
- *
- * @returns An array of ModelMessages.
- */
-export async function convertToModelMessages<UI_MESSAGE extends UIMessage>(
-  messages: Array<Omit<UI_MESSAGE, 'id'>>,
-  options?: {
-    tools?: ToolSet;
-    ignoreIncompleteToolCalls?: boolean;
-    convertDataPart?: (
-      part: DataUIPart<InferUIMessageData<UI_MESSAGE>>,
-    ) => TextPart | FilePart | undefined;
-  },
-): Promise<ModelMessage[]> {
-  const modelMessages: ModelMessage[] = [];
-
-  if (options?.ignoreIncompleteToolCalls) {
-    messages = messages.map(message => ({
-      ...message,
-      parts: message.parts.filter(
-        part =>
-          !isToolUIPart(part) ||
-          (part.state !== 'input-streaming' &&
-            part.state !== 'input-available'),
-      ),
-    }));
-  }
-
-  for (const message of messages) {
-    switch (message.role) {
-      case 'system': {
-        const textParts = message.parts.filter(
-          (part): part is TextUIPart => part.type === 'text',
-        );
-
-        const providerMetadata = textParts.reduce((acc, part) => {
-          if (part.providerMetadata != null) {
-            return { ...acc, ...part.providerMetadata };
-          }
-          return acc;
-        }, {});
-
-        modelMessages.push({
-          role: 'system',
-          content: textParts.map(part => part.text).join(''),
-          ...(Object.keys(providerMetadata).length > 0
-            ? { providerOptions: providerMetadata }
-            : {}),
-        });
-        break;
-      }
-
-      case 'user': {
-        modelMessages.push({
-          role: 'user',
-          content: message.parts
-            .map((part): TextPart | FilePart | undefined => {
-              // Process text parts
-              if (isTextUIPart(part)) {
-                return {
-                  type: 'text' as const,
-                  text: part.text,
-                  ...(part.providerMetadata != null
-                    ? { providerOptions: part.providerMetadata }
-                    : {}),
-                };
-              }
-
-              // Process file parts
-              if (isFileUIPart(part)) {
-                return {
-                  type: 'file' as const,
-                  mediaType: part.mediaType,
-                  filename: part.filename,
-                  data: part.url,
-                  ...(part.providerMetadata != null
-                    ? { providerOptions: part.providerMetadata }
-                    : {}),
-                };
-              }
-
-              // Process data parts with converter if provided
-              if (isDataUIPart(part)) {
-                return options?.convertDataPart?.(
-                  part as DataUIPart<InferUIMessageData<UI_MESSAGE>>,
-                );
-              }
-            })
-            .filter(isNonNullable),
-        });
-
-        break;
-      }
-
-      case 'assistant': {
-        if (message.parts != null) {
-          let block: Array<
-            | TextUIPart
-            | ToolUIPart<InferUIMessageTools<UI_MESSAGE>>
-            | ReasoningUIPart
-            | FileUIPart
-            | DynamicToolUIPart
-            | DataUIPart<InferUIMessageData<UI_MESSAGE>>
-          > = [];
-
-          async function processBlock() {
-            if (block.length === 0) {
-              return;
-            }
-
-            const content: AssistantContent = [];
-
-            for (const part of block) {
-              if (isTextUIPart(part)) {
-                content.push({
-                  type: 'text' as const,
-                  text: part.text,
-                  ...(part.providerMetadata != null
-                    ? { providerOptions: part.providerMetadata }
-                    : {}),
-                });
-              } else if (isFileUIPart(part)) {
-                content.push({
-                  type: 'file' as const,
-                  mediaType: part.mediaType,
-                  filename: part.filename,
-                  data: part.url,
-                  ...(part.providerMetadata != null
-                    ? { providerOptions: part.providerMetadata }
-                    : {}),
-                });
-              } else if (isReasoningUIPart(part)) {
-                content.push({
-                  type: 'reasoning' as const,
-                  text: part.text,
-                  providerOptions: part.providerMetadata,
-                });
-              } else if (isToolUIPart(part)) {
-                const toolName = getToolName(part);
-
-                if (part.state !== 'input-streaming') {
-                  content.push({
-                    type: 'tool-call' as const,
-                    toolCallId: part.toolCallId,
-                    toolName,
-                    input:
-                      part.state === 'output-error'
-                        ? (part.input ??
-                          ('rawInput' in part ? part.rawInput : undefined))
-                        : part.input,
-                    providerExecuted: part.providerExecuted,
-                    ...(part.callProviderMetadata != null
-                      ? { providerOptions: part.callProviderMetadata }
-                      : {}),
-                  });
-
-                  if (part.approval != null) {
-                    content.push({
-                      type: 'tool-approval-request' as const,
-                      approvalId: part.approval.id,
-                      toolCallId: part.toolCallId,
-                    });
-                  }
-
-                  if (
-                    part.providerExecuted === true &&
-                    part.state !== 'approval-responded' &&
-                    (part.state === 'output-available' ||
-                      part.state === 'output-error')
-                  ) {
-                    const resultProviderMetadata =
-                      part.resultProviderMetadata ?? part.callProviderMetadata;
-
-                    content.push({
-                      type: 'tool-result',
-                      toolCallId: part.toolCallId,
-                      toolName,
-                      output: await createToolModelOutput({
-                        toolCallId: part.toolCallId,
-                        input: part.input,
-                        output:
-                          part.state === 'output-error'
-                            ? part.errorText
-                            : part.output,
-                        tool: options?.tools?.[toolName],
-                        errorMode:
-                          part.state === 'output-error' ? 'json' : 'none',
-                      }),
-                      ...(resultProviderMetadata != null
-                        ? { providerOptions: resultProviderMetadata }
-                        : {}),
-                    });
-                  }
-                }
-              } else if (isDataUIPart(part)) {
-                const dataPart = options?.convertDataPart?.(
-                  part as DataUIPart<InferUIMessageData<UI_MESSAGE>>,
-                );
-
-                if (dataPart != null) {
-                  content.push(dataPart);
-                }
-              } else {
-                const _exhaustiveCheck: never = part;
-                throw new Error(`Unsupported part: ${_exhaustiveCheck}`);
-              }
-            }
-
-            modelMessages.push({
-              role: 'assistant',
-              content,
-            });
-
-            // check if there are tool invocations with results in the block
-            // Include non-provider-executed tools, OR provider-executed tools with approval responses
-            const toolParts = block.filter(
-              part =>
-                isToolUIPart(part) &&
-                (part.providerExecuted !== true ||
-                  part.approval?.approved != null),
-            ) as (
-              | ToolUIPart<InferUIMessageTools<UI_MESSAGE>>
-              | DynamicToolUIPart
-            )[];
-
-            // tool message with tool results
-            if (toolParts.length > 0) {
-              {
-                const content: Array<ToolResultPart | ToolApprovalResponse> =
-                  [];
-                for (const toolPart of toolParts) {
-                  // add approval response for approved tool calls:
-                  if (toolPart.approval?.approved != null) {
-                    content.push({
-                      type: 'tool-approval-response' as const,
-                      approvalId: toolPart.approval.id,
-                      approved: toolPart.approval.approved,
-                      reason: toolPart.approval.reason,
-                      providerExecuted: toolPart.providerExecuted,
-                    });
-                  }
-
-                  // For provider-executed tools, the tool result is already in the
-                  // assistant content. Skip adding to tool message to avoid duplicates
-                  // (which would create orphaned function_call_output entries).
-                  if (toolPart.providerExecuted === true) {
-                    continue;
-                  }
-
-                  switch (toolPart.state) {
-                    case 'output-denied': {
-                      content.push({
-                        type: 'tool-result',
-                        toolCallId: toolPart.toolCallId,
-                        toolName: getToolName(toolPart),
-                        output: {
-                          type: 'error-text' as const,
-                          value:
-                            toolPart.approval.reason ??
-                            'Tool execution denied.',
-                        },
-                        ...(toolPart.callProviderMetadata != null
-                          ? { providerOptions: toolPart.callProviderMetadata }
-                          : {}),
-                      });
-                      break;
-                    }
-
-                    case 'output-error':
-                    case 'output-available': {
-                      const toolName = getToolName(toolPart);
-                      content.push({
-                        type: 'tool-result',
-                        toolCallId: toolPart.toolCallId,
-                        toolName,
-                        output: await createToolModelOutput({
-                          toolCallId: toolPart.toolCallId,
-                          input: toolPart.input,
-                          output:
-                            toolPart.state === 'output-error'
-                              ? toolPart.errorText
-                              : toolPart.output,
-                          tool: options?.tools?.[toolName],
-                          errorMode:
-                            toolPart.state === 'output-error' ? 'text' : 'none',
-                        }),
-                        ...(toolPart.callProviderMetadata != null
-                          ? { providerOptions: toolPart.callProviderMetadata }
-                          : {}),
-                      });
-                      break;
-                    }
-                  }
-                }
-
-                if (content.length > 0) {
-                  modelMessages.push({
-                    role: 'tool',
-                    content,
-                  });
-                }
-              }
-            }
-
-            // updates for next block
-            block = [];
-          }
-
-          for (const part of message.parts) {
-            if (
-              isTextUIPart(part) ||
-              isReasoningUIPart(part) ||
-              isFileUIPart(part) ||
-              isToolUIPart(part) ||
-              isDataUIPart(part)
-            ) {
-              block.push(part as (typeof block)[number]);
-            } else if (part.type === 'step-start') {
-              await processBlock();
-            }
-          }
-
-          await processBlock();
-
-          break;
-        }
-
-        break;
-      }
-
-      default: {
-        const _exhaustiveCheck: never = message.role;
-        throw new MessageConversionError({
-          originalMessage: message,
-          message: `Unsupported role: ${_exhaustiveCheck}`,
-        });
-      }
-    }
-  }
-
-  return modelMessages;
-}

package/node_modules/ai/src/ui/default-chat-transport.ts

@@ -1,36 +0,0 @@
-import { parseJsonEventStream, ParseResult } from '@ai-sdk/provider-utils';
-import {
-  UIMessageChunk,
-  uiMessageChunkSchema,
-} from '../ui-message-stream/ui-message-chunks';
-import {
-  HttpChatTransport,
-  HttpChatTransportInitOptions,
-} from './http-chat-transport';
-import { UIMessage } from './ui-messages';
-
-export class DefaultChatTransport<
-  UI_MESSAGE extends UIMessage,
-> extends HttpChatTransport<UI_MESSAGE> {
-  constructor(options: HttpChatTransportInitOptions<UI_MESSAGE> = {}) {
-    super(options);
-  }
-
-  protected processResponseStream(
-    stream: ReadableStream<Uint8Array<ArrayBufferLike>>,
-  ): ReadableStream<UIMessageChunk> {
-    return parseJsonEventStream({
-      stream,
-      schema: uiMessageChunkSchema,
-    }).pipeThrough(
-      new TransformStream<ParseResult<UIMessageChunk>, UIMessageChunk>({
-        async transform(chunk, controller) {
-          if (!chunk.success) {
-            throw chunk.error;
-          }
-          controller.enqueue(chunk.value);
-        },
-      }),
-    );
-  }
-}

package/node_modules/ai/src/ui/direct-chat-transport.ts

@@ -1,117 +0,0 @@
-import { Output } from '../generate-text/output';
-import { UIMessageStreamOptions } from '../generate-text/stream-text-result';
-import { ToolSet } from '../generate-text/tool-set';
-import { UIMessageChunk } from '../ui-message-stream/ui-message-chunks';
-import { Agent } from '../agent/agent';
-import { ChatTransport } from './chat-transport';
-import { convertToModelMessages } from './convert-to-model-messages';
-import { InferUITools, UIMessage } from './ui-messages';
-import { validateUIMessages } from './validate-ui-messages';
-
-/**
- * Options for the `DirectChatTransport` class.
- */
-export type DirectChatTransportOptions<
-  CALL_OPTIONS,
-  TOOLS extends ToolSet,
-  OUTPUT extends Output,
-  UI_MESSAGE extends UIMessage<unknown, never, InferUITools<TOOLS>>,
-> = {
-  /**
-   * The agent to use for generating responses.
-   */
-  agent: Agent<CALL_OPTIONS, TOOLS, OUTPUT>;
-
-  /**
-   * Options to pass to the agent when calling it.
-   */
-  options?: CALL_OPTIONS;
-} & Omit<UIMessageStreamOptions<UI_MESSAGE>, 'onFinish'>;
-
-/**
- * A transport that directly communicates with an Agent in-process,
- * without going through HTTP. This is useful for:
- * - Server-side rendering scenarios
- * - Testing without network
- * - Single-process applications
- *
- * @example
- * ```tsx
- * import { useChat } from '@ai-sdk/react';
- * import { DirectChatTransport } from 'ai';
- * import { myAgent } from './my-agent';
- *
- * const { messages, sendMessage } = useChat({
- *   transport: new DirectChatTransport({ agent: myAgent }),
- * });
- * ```
- */
-export class DirectChatTransport<
-  CALL_OPTIONS = never,
-  TOOLS extends ToolSet = {},
-  OUTPUT extends Output = never,
-  UI_MESSAGE extends UIMessage<unknown, never, InferUITools<TOOLS>> = UIMessage<
-    unknown,
-    never,
-    InferUITools<TOOLS>
-  >,
-> implements ChatTransport<UI_MESSAGE> {
-  private readonly agent: Agent<CALL_OPTIONS, TOOLS, OUTPUT>;
-  private readonly agentOptions: CALL_OPTIONS | undefined;
-  private readonly uiMessageStreamOptions: Omit<
-    UIMessageStreamOptions<UI_MESSAGE>,
-    'onFinish'
-  >;
-
-  constructor({
-    agent,
-    options,
-    ...uiMessageStreamOptions
-  }: DirectChatTransportOptions<CALL_OPTIONS, TOOLS, OUTPUT, UI_MESSAGE>) {
-    this.agent = agent;
-    this.agentOptions = options;
-    this.uiMessageStreamOptions = uiMessageStreamOptions;
-  }
-
-  async sendMessages({
-    messages,
-    abortSignal,
-  }: Parameters<ChatTransport<UI_MESSAGE>['sendMessages']>[0]): Promise<
-    ReadableStream<UIMessageChunk>
-  > {
-    // Validate the incoming UI messages
-    const validatedMessages = await validateUIMessages<UI_MESSAGE>({
-      messages,
-      tools: this.agent.tools,
-    });
-
-    // Convert UI messages to model messages
-    const modelMessages = await convertToModelMessages(validatedMessages, {
-      tools: this.agent.tools,
-    });
-
-    // Stream from the agent
-    const result = await this.agent.stream({
-      prompt: modelMessages,
-      abortSignal,
-      ...(this.agentOptions !== undefined
-        ? { options: this.agentOptions }
-        : {}),
-    } as Parameters<Agent<CALL_OPTIONS, TOOLS, OUTPUT>['stream']>[0]);
-
-    // Return the UI message stream
-    return result.toUIMessageStream(this.uiMessageStreamOptions);
-  }
-
-  /**
-   * Direct transport does not support reconnection since there is no
-   * persistent server-side stream to reconnect to.
-   *
-   * @returns Always returns `null`
-   */
-  async reconnectToStream(
-    _options: Parameters<ChatTransport<UI_MESSAGE>['reconnectToStream']>[0],
-  ): Promise<ReadableStream<UIMessageChunk> | null> {
-    return null;
-  }
-}