blink 0.1.54 → 0.1.55

package/dist/index-BgJpZoBy.d.cts

@@ -0,0 +1,102 @@
+import { Chat, ExperimentalCompletion } from "./index-IWju3eNc.cjs";
+import { UIMessage, UIMessageChunk } from "ai";
+
+//#region src/http/async-iterable-stream.d.ts
+/**
+ * A type that combines AsyncIterable and ReadableStream.
+ * This allows a ReadableStream to be consumed using for-await-of syntax.
+ */
+type AsyncIterableStream$1<T> = AsyncIterable<T> & ReadableStream<T>;
+/**
+ * Wraps a ReadableStream and returns an object that is both a ReadableStream and an AsyncIterable.
+ * This enables consumption of the stream using for-await-of, with proper resource cleanup on early exit or error.
+ *
+ * @template T The type of the stream's chunks.
+ * @param source The source ReadableStream to wrap.
+ * @returns An AsyncIterableStream that can be used as both a ReadableStream and an AsyncIterable.
+ */
+declare function createAsyncIterableStream<T>(source: ReadableStream<T>): AsyncIterableStream$1<T>;
+//#endregion
+//#region src/api/internal/client.d.ts
+/**
+ * APIServerURLEnvironmentVariable is the environment variable that
+ * the Blink agent uses for executions to the `blink.*` API.
+ * (e.g. blink.chat.upsert).
+ */
+declare const APIServerURLEnvironmentVariable = "BLINK_API_SERVER_URL";
+//#endregion
+//#region src/http/client.d.ts
+/**
+ * StreamResponseFormatHeader indicates to a client the stream response
+ * format that the agent is using.
+ */
+declare const StreamResponseFormatHeader = "x-blink-stream-response-format";
+/**
+ * SendMessagesRequest is the request format of the `/_agent/send-messages` endpoint.
+ *
+ * It executes the `sendMessages` function.
+ */
+interface SendMessagesRequest {
+  readonly messages: UIMessage[];
+  readonly chat: Chat;
+}
+/**
+ * ExperimentalProvideCompletionsRequest is the request format of the `/_agent/completions` endpoint.
+ *
+ * It executes the `experimental_provideCompletions` function.
+ */
+interface ExperimentalProvideCompletionsRequest {
+  readonly messages: UIMessage[];
+  readonly chat?: Chat;
+  readonly input: string;
+  readonly caret: number;
+  readonly selection?: [number, number];
+}
+/**
+ * CapabilitiesResponse is the response format of the `/_agent/capabilities` endpoint.
+ *
+ * It indicates whether the agent supports requests and completions.
+ */
+interface CapabilitiesResponse {
+  readonly requests: boolean;
+  readonly completions: boolean;
+}
+interface ClientOptions {
+  readonly baseUrl: string;
+  readonly headers?: Record<string, string>;
+}
+/**
+ * Client is a client for the Blink agent HTTP API.
+ */
+declare class Client {
+  private readonly options;
+  constructor(options: ClientOptions);
+  get baseUrl(): string;
+  /**
+   * sendMessages sends messages to the agent.
+   *
+   * The response format is automatically converted to a UI message stream.
+   */
+  sendMessages(request: SendMessagesRequest, options?: {
+    signal?: AbortSignal;
+  }): Promise<AsyncIterableStream$1<UIMessageChunk>>;
+  /**
+   * experimental_provideCompletions provides completions to the user.
+   * This is used to provide completions to the user.
+   */
+  experimental_provideCompletions(request: ExperimentalProvideCompletionsRequest): Promise<AsyncIterableStream$1<ExperimentalCompletion>>;
+  /**
+   * capabilities returns the capabilities of the agent.
+   * This is used to check if the agent supports requests and completions.
+   */
+  capabilities(): Promise<CapabilitiesResponse>;
+  /**
+   * health simply returns a 200 response.
+   * This is used to check if the agent is running.
+   */
+  health(): Promise<void>;
+  private handleError;
+}
+declare const streamSSE: <T>(resp: Response) => AsyncIterableStream$1<T>;
+//#endregion
+export { APIServerURLEnvironmentVariable, AsyncIterableStream$1 as AsyncIterableStream, CapabilitiesResponse, Client, ClientOptions, ExperimentalProvideCompletionsRequest, SendMessagesRequest, StreamResponseFormatHeader, createAsyncIterableStream, streamSSE };

package/dist/index-IWju3eNc.d.cts

@@ -0,0 +1,286 @@
+import * as _ai_sdk_provider0 from "@ai-sdk/provider";
+import * as ai0 from "ai";
+import { AsyncIterableStream, InferUIMessageChunk, Tool, ToolSet, UIDataTypes, UIMessage, UIMessagePart, UITools } from "ai";
+import http from "http";
+
+//#region src/api/chat.d.ts
+interface Chat {
+  readonly id: string;
+}
+type ChatBehavior = "enqueue" | "interrupt" | "append";
+interface MessageOptions {
+  /**
+   * behavior of the chat when sending this message.
+   *
+   * - "enqueue" will add messages to the chat and start the chat eventually.
+   * - "interrupt" will interrupt the chat if running and send messages.
+   * - "append" will add messages to the chat.
+   */
+  readonly behavior?: ChatBehavior;
+}
+interface Message<METADATA = unknown, DATA_TYPES extends UIDataTypes = UIDataTypes, TOOLS extends UITools = UITools> {
+  readonly role: UIMessage["role"];
+  readonly parts: UIMessagePart<DATA_TYPES, TOOLS>[];
+  readonly metadata?: METADATA;
+}
+declare const chat: Readonly<{
+  upsert: (id: string) => Promise<Chat>;
+  message: (id: string, message: Message, options?: MessageOptions) => Promise<void>;
+}>;
+//#endregion
+//#region src/api/tools.d.ts
+/**
+ * ToolWithContext is a tool that supports the "withContext" method.
+ *
+ * @param CONTEXT The context type.
+ * @param TOOL The tool type.
+ * @returns The tool with the given context.
+ */
+type ToolWithContext<CONTEXT, TOOL extends Tool> = TOOL & {
+  withContext(context: CONTEXT): TOOL;
+};
+/**
+ * Tools are helpers for managing tools.
+ */
+declare const tools: {
+  /**
+   * withContext adds context to a set of tools that supports the "withContext" method.
+   *
+   * @param context
+   * @param tools
+   * @returns
+   */
+  withContext<const TOOLS extends ToolsWithContext>(tools: TOOLS, context: ContextFromTools<TOOLS>): { [K in keyof TOOLS]: Tool };
+  /**
+   * @internal
+   * @deprecated Use withContext instead - it's the same thing.
+   */
+  with<const TOOLS extends ToolsWithContext>(tools: TOOLS, context: ContextFromTools<TOOLS>): { [K in keyof TOOLS]: Tool };
+  /**
+   * withApproval ensures a set of tools need explicit user approval
+   * before they are executed.
+   *
+   * This works by replacing the execution of all provided tools with
+   * special output that interfaces must handle.
+   *
+   * On approval, the tool will be executed with the verbatim input.
+   *
+   * @returns Tools that should be sent in `streamText`.
+   */
+  withApproval<TOOLS extends ToolSet, MESSAGE extends UIMessage>(options: {
+    messages: MESSAGE[];
+    tools: TOOLS;
+    abortSignal?: AbortSignal;
+  }): Promise<TOOLS>;
+  /**
+   * prefix adds a prefix to all the tools in a tool set.
+   *
+   * @param tools The tool set to prefix.
+   * @param prefix The prefix to add to the tools.
+   * @returns The prefixed tool set.
+   */
+  prefix(tools: ToolSet, prefix: string): ToolSet;
+};
+type ToolsWithContext = Record<string, Tool & {
+  withContext(context: unknown): Tool;
+}>;
+type ContextFromTools<TOOLS extends ToolsWithContext> = TOOLS[keyof TOOLS] extends {
+  withContext(context: infer C): any;
+} ? C : never;
+/**
+ * ToolApprovalOutput is the output of a tool that requires approval.
+ *
+ * This should be consumed by the UI to display an approval prompt.
+ */
+interface ToolApprovalOutput {
+  type: "tool-approval";
+  outcome: "pending" | "approved" | "rejected";
+  reason?: string;
+}
+/**
+ * isToolApprovalOutput checks if an output is a tool approval output.
+ */
+declare function isToolApprovalOutput(output: unknown): output is ToolApprovalOutput;
+//#endregion
+//#region src/api/storage.d.ts
+/**
+ * Storage allows agents to persist data.
+ * Every agent has it's own persistent storage namespace.
+ */
+declare const storage: Readonly<{
+  kv: Readonly<{
+    get: (key: string) => Promise<string | undefined>;
+    set: (key: string, value: string) => Promise<void>;
+    del: (key: string) => Promise<void>;
+  }>;
+}>;
+//#endregion
+//#region src/api/index.d.ts
+/**
+ * SendMessagesResponse is the response of the sendMessages function.
+ * It can be a stream of messages or an arbitrary response.
+ */
+type SendMessagesResponse = {
+  toUIMessageStream(): AsyncIterableStream<InferUIMessageChunk<UIMessage>>;
+} | Response | ReadableStream<InferUIMessageChunk<UIMessage>>;
+/**
+ * SendMessagesOptions is the options for the sendMessages function.
+ */
+interface SendMessagesOptions<MESSAGE extends UIMessage = UIMessage> {
+  /**
+   * Messages are all messages for the history of the chat.
+   * It is the user's responsibility to manage context for the chat.
+   */
+  readonly messages: MESSAGE[];
+  /**
+   * Chat is the associated chat for the messages.
+   */
+  readonly chat: Chat;
+  /**
+   * abortSignal can be used to terminate streaming operations
+   * immediately when the streaming request ends.
+   */
+  readonly abortSignal?: AbortSignal;
+}
+interface ExperimentalProvideCompletionsOptions<MESSAGE extends UIMessage = UIMessage> {
+  /**
+   * The chat for the completions.
+   * Omitted if there is no chat.
+   */
+  readonly chat?: Chat;
+  /**
+   * Messages that are part of the current chat.
+   * Omitted if there is no chat.
+   */
+  readonly messages?: MESSAGE[];
+  readonly input: string;
+  readonly caret: number;
+  readonly selection?: [number, number];
+  readonly abortSignal?: AbortSignal;
+}
+type ExperimentalCompletion = {
+  text: string;
+  replace?: [number, number];
+} | {
+  id: string;
+  label: string;
+  detail?: string;
+  insertText?: string;
+  replace?: [number, number];
+};
+type ExperimentalProvideCompletionsResponse = ReadableStream<ExperimentalCompletion> | Promise<ReadableStream<ExperimentalCompletion>> | Promise<ExperimentalCompletion> | ExperimentalCompletion;
+interface AgentOptions<MESSAGE extends UIMessage = UIMessage> {
+  /**
+   * sendMessages is called when the agent is streaming chat messages.
+   * This is invoked on chat creation, and can be programatically
+   * invoked at any time with `blink.chat.message`.
+   */
+  sendMessages(options: SendMessagesOptions<MESSAGE>): Promise<SendMessagesResponse> | SendMessagesResponse;
+  /**
+   * onRequest is called when the agent receives a request.
+   * This is for handling webhooks, or incoming client payloads
+   * that warrant a response.
+   *
+   * @param request The request received by the agent.
+   * @returns A response to the request. If void, the agent will
+   *          respond with a 404.
+   */
+  onRequest?(request: Request): Promise<Response | void>;
+  /**
+   * experimental_provideCompletions is called when the user is typing in the chat input.
+   * This is used to provide completions to the user.
+   *
+   * *NOTE*: This *only* works in the browser at the moment.
+   *
+   * @param options The options for the completions.
+   * @returns A stream of completions, or a single completion.
+   */
+  experimental_provideCompletions?(options: ExperimentalProvideCompletionsOptions<MESSAGE>): ExperimentalProvideCompletionsResponse;
+}
+/**
+ * A Blink agent is simply an HTTP handler with a reserved
+ * "/_agent/" path used for agent-specific requests.
+ *
+ * The environment variable "BLINK_API_SERVER_URL" is used
+ * to serve responses to the `blink.*` API. (e.g. blink.chat.upsert).
+ */
+interface Agent {
+  /**
+   * fetch is the HTTP handler for the agent.
+   *
+   * @param request The request to handle.
+   * @returns A response to the request.
+   */
+  fetch(request: Request): Promise<Response> | Response;
+  /**
+   * serve starts the agent as an unauthenticated HTTP server.
+   * This is required for use in the Blink Cloud or with the Blink CLI.
+   *
+   * @param options Optional options for the server.
+   * @returns A Node.JS HTTP server.
+   */
+  serve(options?: ServeOptions): http.Server;
+}
+/**
+ * ServeOptions is the options for the `.serve()` method.
+ */
+type ServeOptions = {
+  readonly host?: string;
+  readonly port?: number;
+};
+/**
+ * agent creates an HTTP handler that when served
+ * speaks the Blink agent protocol.
+ *
+ * Call `.serve()` to serve the agent for use in
+ * the Blink Cloud or with the Blink CLI.
+ */
+declare function agent<MESSAGE extends UIMessage = UIMessage>(agent: AgentOptions<MESSAGE>): Agent;
+type StreamResponseFormat = "ui-message" | "openai-chat" | "openai-response" | "anthropic" | "google" | "xai";
+declare function withResponseFormat(response: Response, format: StreamResponseFormat): Response;
+/**
+ * model returns an AI SDK model that is authenticated through Blink.
+ *
+ * Blink's AI Gateway uses Vercel's AI Gateway under-the-hood, and passes
+ * through billing cost without any upcharge.
+ *
+ * Feel free to use any provide you'd like.
+ *
+ * @param modelName - See: https://vercel.com/ai-gateway/models
+ * @returns An AI SDK model that is authenticated through Blink.
+ */
+declare const model: (modelName: string) => _ai_sdk_provider0.LanguageModelV2;
+declare const _default: {
+  agent: typeof agent;
+  chat: Readonly<{
+    upsert: (id: string) => Promise<Chat>;
+    message: (id: string, message: Message, options?: MessageOptions) => Promise<void>;
+  }>;
+  storage: Readonly<{
+    kv: Readonly<{
+      get: (key: string) => Promise<string | undefined>;
+      set: (key: string, value: string) => Promise<void>;
+      del: (key: string) => Promise<void>;
+    }>;
+  }>;
+  tools: {
+    withContext<const TOOLS extends {
+      [x: string]: ai0.Tool & {
+        withContext(context: unknown): ai0.Tool;
+      };
+    }>(tools: TOOLS, context: ContextFromTools<TOOLS>): { [K in keyof TOOLS]: ai0.Tool };
+    with<const TOOLS extends {
+      [x: string]: ai0.Tool & {
+        withContext(context: unknown): ai0.Tool;
+      };
+    }>(tools: TOOLS, context: ContextFromTools<TOOLS>): { [K in keyof TOOLS]: ai0.Tool };
+    withApproval<TOOLS extends ai0.ToolSet, MESSAGE extends UIMessage>(options: {
+      messages: MESSAGE[];
+      tools: TOOLS;
+      abortSignal?: AbortSignal;
+    }): Promise<TOOLS>;
+    prefix(tools: ai0.ToolSet, prefix: string): ai0.ToolSet;
+  };
+};
+//#endregion
+export { Agent, AgentOptions, Chat, ChatBehavior, ContextFromTools, ExperimentalCompletion, ExperimentalProvideCompletionsOptions, ExperimentalProvideCompletionsResponse, Message, MessageOptions, SendMessagesOptions, SendMessagesResponse, ServeOptions, StreamResponseFormat, ToolApprovalOutput, ToolWithContext, _default, agent, chat, isToolApprovalOutput, model, storage, tools, withResponseFormat };

package/dist/index-auvvMWNH.d.ts

@@ -0,0 +1,102 @@
+import { Chat, ExperimentalCompletion } from "./index-tvf1rglX.js";
+import { UIMessage, UIMessageChunk } from "ai";
+
+//#region src/http/async-iterable-stream.d.ts
+/**
+ * A type that combines AsyncIterable and ReadableStream.
+ * This allows a ReadableStream to be consumed using for-await-of syntax.
+ */
+type AsyncIterableStream$1<T> = AsyncIterable<T> & ReadableStream<T>;
+/**
+ * Wraps a ReadableStream and returns an object that is both a ReadableStream and an AsyncIterable.
+ * This enables consumption of the stream using for-await-of, with proper resource cleanup on early exit or error.
+ *
+ * @template T The type of the stream's chunks.
+ * @param source The source ReadableStream to wrap.
+ * @returns An AsyncIterableStream that can be used as both a ReadableStream and an AsyncIterable.
+ */
+declare function createAsyncIterableStream<T>(source: ReadableStream<T>): AsyncIterableStream$1<T>;
+//#endregion
+//#region src/api/internal/client.d.ts
+/**
+ * APIServerURLEnvironmentVariable is the environment variable that
+ * the Blink agent uses for executions to the `blink.*` API.
+ * (e.g. blink.chat.upsert).
+ */
+declare const APIServerURLEnvironmentVariable = "BLINK_API_SERVER_URL";
+//#endregion
+//#region src/http/client.d.ts
+/**
+ * StreamResponseFormatHeader indicates to a client the stream response
+ * format that the agent is using.
+ */
+declare const StreamResponseFormatHeader = "x-blink-stream-response-format";
+/**
+ * SendMessagesRequest is the request format of the `/_agent/send-messages` endpoint.
+ *
+ * It executes the `sendMessages` function.
+ */
+interface SendMessagesRequest {
+  readonly messages: UIMessage[];
+  readonly chat: Chat;
+}
+/**
+ * ExperimentalProvideCompletionsRequest is the request format of the `/_agent/completions` endpoint.
+ *
+ * It executes the `experimental_provideCompletions` function.
+ */
+interface ExperimentalProvideCompletionsRequest {
+  readonly messages: UIMessage[];
+  readonly chat?: Chat;
+  readonly input: string;
+  readonly caret: number;
+  readonly selection?: [number, number];
+}
+/**
+ * CapabilitiesResponse is the response format of the `/_agent/capabilities` endpoint.
+ *
+ * It indicates whether the agent supports requests and completions.
+ */
+interface CapabilitiesResponse {
+  readonly requests: boolean;
+  readonly completions: boolean;
+}
+interface ClientOptions {
+  readonly baseUrl: string;
+  readonly headers?: Record<string, string>;
+}
+/**
+ * Client is a client for the Blink agent HTTP API.
+ */
+declare class Client {
+  private readonly options;
+  constructor(options: ClientOptions);
+  get baseUrl(): string;
+  /**
+   * sendMessages sends messages to the agent.
+   *
+   * The response format is automatically converted to a UI message stream.
+   */
+  sendMessages(request: SendMessagesRequest, options?: {
+    signal?: AbortSignal;
+  }): Promise<AsyncIterableStream$1<UIMessageChunk>>;
+  /**
+   * experimental_provideCompletions provides completions to the user.
+   * This is used to provide completions to the user.
+   */
+  experimental_provideCompletions(request: ExperimentalProvideCompletionsRequest): Promise<AsyncIterableStream$1<ExperimentalCompletion>>;
+  /**
+   * capabilities returns the capabilities of the agent.
+   * This is used to check if the agent supports requests and completions.
+   */
+  capabilities(): Promise<CapabilitiesResponse>;
+  /**
+   * health simply returns a 200 response.
+   * This is used to check if the agent is running.
+   */
+  health(): Promise<void>;
+  private handleError;
+}
+declare const streamSSE: <T>(resp: Response) => AsyncIterableStream$1<T>;
+//#endregion
+export { APIServerURLEnvironmentVariable, AsyncIterableStream$1 as AsyncIterableStream, CapabilitiesResponse, Client, ClientOptions, ExperimentalProvideCompletionsRequest, SendMessagesRequest, StreamResponseFormatHeader, createAsyncIterableStream, streamSSE };