@jmoyers/harness 0.1.8 → 0.1.10

package/packages/harness-ai/src/types.ts

@@ -0,0 +1,330 @@
+type JsonPrimitive = string | number | boolean | null;
+
+export type JsonValue = JsonPrimitive | JsonObject | JsonValue[];
+
+interface JsonObject {
+  readonly [key: string]: JsonValue;
+}
+
+export interface JsonSchema {
+  readonly [key: string]: JsonValue;
+}
+
+export type FinishReason = 'stop' | 'length' | 'content-filter' | 'tool-calls' | 'error' | 'other';
+
+export interface LanguageModelUsage {
+  readonly inputTokens: number;
+  readonly outputTokens: number;
+  readonly totalTokens: number;
+  readonly reasoningTokens?: number;
+  readonly cachedInputTokens?: number;
+}
+
+export interface LanguageModelRequestMetadata {
+  readonly body: Record<string, unknown>;
+}
+
+export interface LanguageModelResponseMetadata {
+  readonly id?: string;
+  readonly modelId?: string;
+  readonly timestamp?: Date;
+  readonly headers?: Headers;
+}
+
+export type ProviderMetadata = Record<string, Record<string, unknown>>;
+
+export interface FunctionToolDefinition<INPUT = unknown, OUTPUT = unknown> {
+  readonly type?: 'function';
+  readonly description?: string;
+  readonly inputSchema?: JsonSchema;
+  readonly execute?: (input: INPUT) => Promise<OUTPUT> | OUTPUT;
+  readonly dynamic?: boolean;
+  readonly title?: string;
+}
+
+export interface AnthropicProviderToolDefinition {
+  readonly type: 'provider';
+  readonly provider: 'anthropic';
+  readonly anthropicType: string;
+  readonly name: string;
+  readonly description?: string;
+  readonly inputSchema?: JsonSchema;
+  readonly settings?: Record<string, JsonValue>;
+  readonly dynamic?: boolean;
+  readonly title?: string;
+}
+
+export type ToolDefinition<INPUT = unknown, OUTPUT = unknown> =
+  | FunctionToolDefinition<INPUT, OUTPUT>
+  | AnthropicProviderToolDefinition;
+
+export type ToolSet = Record<string, ToolDefinition<unknown, unknown>>;
+
+type ToolName<TOOLS extends ToolSet> = Extract<keyof TOOLS, string>;
+
+export interface TypedToolCall<TOOLS extends ToolSet> {
+  readonly toolCallId: string;
+  readonly toolName: ToolName<TOOLS> | string;
+  readonly input: unknown;
+  readonly providerExecuted?: boolean;
+  readonly dynamic?: boolean;
+  readonly providerMetadata?: ProviderMetadata;
+  readonly title?: string;
+  readonly invalid?: boolean;
+  readonly error?: string;
+}
+
+export interface TypedToolResult<TOOLS extends ToolSet> {
+  readonly toolCallId: string;
+  readonly toolName: ToolName<TOOLS> | string;
+  readonly output: unknown;
+  readonly input?: unknown;
+  readonly providerExecuted?: boolean;
+  readonly preliminary?: boolean;
+  readonly dynamic?: boolean;
+}
+
+export interface TypedToolError<TOOLS extends ToolSet> {
+  readonly toolCallId: string;
+  readonly toolName: ToolName<TOOLS> | string;
+  readonly error: unknown;
+  readonly input?: unknown;
+  readonly providerExecuted?: boolean;
+  readonly dynamic?: boolean;
+}
+
+export interface TextContentPart {
+  readonly type: 'text';
+  readonly text: string;
+}
+
+export interface AssistantToolCallPart {
+  readonly type: 'tool-call';
+  readonly toolCallId: string;
+  readonly toolName: string;
+  readonly input: unknown;
+}
+
+export interface ToolResultContentPart {
+  readonly type: 'tool-result';
+  readonly toolCallId: string;
+  readonly toolName: string;
+  readonly output: unknown;
+  readonly isError?: boolean;
+}
+
+interface SystemModelMessage {
+  readonly role: 'system';
+  readonly content: string;
+}
+
+interface UserModelMessage {
+  readonly role: 'user';
+  readonly content: string | TextContentPart[];
+}
+
+export interface AssistantModelMessage {
+  readonly role: 'assistant';
+  readonly content: string | (TextContentPart | AssistantToolCallPart)[];
+}
+
+export interface ToolModelMessage {
+  readonly role: 'tool';
+  readonly content: ToolResultContentPart[];
+}
+
+export type ModelMessage =
+  | SystemModelMessage
+  | UserModelMessage
+  | AssistantModelMessage
+  | ToolModelMessage;
+
+export interface HarnessAnthropicModel {
+  readonly provider: 'harness.anthropic';
+  readonly modelId: string;
+  readonly apiKey: string;
+  readonly baseUrl: string;
+  readonly headers: Record<string, string>;
+  readonly fetch: typeof fetch;
+}
+
+export type StreamTextPart<TOOLS extends ToolSet> =
+  | {
+      readonly type: 'start';
+    }
+  | {
+      readonly type: 'start-step';
+      readonly request: LanguageModelRequestMetadata;
+      readonly warnings: string[];
+    }
+  | {
+      readonly type: 'text-start';
+      readonly id: string;
+      readonly providerMetadata?: ProviderMetadata;
+    }
+  | {
+      readonly type: 'text-delta';
+      readonly id: string;
+      readonly text: string;
+      readonly providerMetadata?: ProviderMetadata;
+    }
+  | {
+      readonly type: 'text-end';
+      readonly id: string;
+      readonly providerMetadata?: ProviderMetadata;
+    }
+  | {
+      readonly type: 'reasoning-start';
+      readonly id: string;
+      readonly providerMetadata?: ProviderMetadata;
+    }
+  | {
+      readonly type: 'reasoning-delta';
+      readonly id: string;
+      readonly text: string;
+      readonly providerMetadata?: ProviderMetadata;
+    }
+  | {
+      readonly type: 'reasoning-end';
+      readonly id: string;
+      readonly providerMetadata?: ProviderMetadata;
+    }
+  | {
+      readonly type: 'tool-input-start';
+      readonly id: string;
+      readonly toolName: ToolName<TOOLS> | string;
+      readonly providerExecuted?: boolean;
+      readonly dynamic?: boolean;
+      readonly title?: string;
+      readonly providerMetadata?: ProviderMetadata;
+    }
+  | {
+      readonly type: 'tool-input-delta';
+      readonly id: string;
+      readonly delta: string;
+      readonly providerMetadata?: ProviderMetadata;
+    }
+  | {
+      readonly type: 'tool-input-end';
+      readonly id: string;
+      readonly providerMetadata?: ProviderMetadata;
+    }
+  | ({ readonly type: 'tool-call' } & TypedToolCall<TOOLS>)
+  | ({ readonly type: 'tool-result' } & TypedToolResult<TOOLS>)
+  | ({ readonly type: 'tool-error' } & TypedToolError<TOOLS>)
+  | {
+      readonly type: 'source';
+      readonly id: string;
+      readonly sourceType: 'url' | 'document';
+      readonly url?: string;
+      readonly title?: string;
+      readonly mediaType?: string;
+      readonly filename?: string;
+      readonly providerMetadata?: ProviderMetadata;
+    }
+  | {
+      readonly type: 'raw';
+      readonly rawValue: unknown;
+    }
+  | {
+      readonly type: 'finish-step';
+      readonly response: LanguageModelResponseMetadata;
+      readonly usage: LanguageModelUsage;
+      readonly finishReason: FinishReason;
+      readonly rawFinishReason?: string;
+      readonly providerMetadata?: ProviderMetadata;
+    }
+  | {
+      readonly type: 'finish';
+      readonly finishReason: FinishReason;
+      readonly rawFinishReason?: string;
+      readonly totalUsage: LanguageModelUsage;
+    }
+  | {
+      readonly type: 'abort';
+      readonly reason?: string;
+    }
+  | {
+      readonly type: 'error';
+      readonly error: unknown;
+    };
+
+export interface UIMessageChunk {
+  readonly type:
+    | 'start'
+    | 'start-step'
+    | 'finish-step'
+    | 'abort'
+    | 'message-metadata'
+    | 'error'
+    | 'text-start'
+    | 'text-delta'
+    | 'text-end'
+    | 'reasoning-start'
+    | 'reasoning-delta'
+    | 'reasoning-end'
+    | 'tool-input-start'
+    | 'tool-input-delta'
+    | 'tool-input-available'
+    | 'tool-input-error'
+    | 'tool-output-available'
+    | 'tool-output-error'
+    | 'source-url'
+    | 'source-document'
+    | 'finish';
+  readonly [key: string]: unknown;
+}
+
+export type AsyncIterableStream<T> = ReadableStream<T> & AsyncIterable<T>;
+
+export interface StreamTextResult<TOOLS extends ToolSet> {
+  readonly fullStream: AsyncIterableStream<StreamTextPart<TOOLS>>;
+  readonly textStream: AsyncIterableStream<string>;
+  readonly text: Promise<string>;
+  readonly toolCalls: Promise<TypedToolCall<TOOLS>[]>;
+  readonly toolResults: Promise<Array<TypedToolResult<TOOLS> | TypedToolError<TOOLS>>>;
+  readonly finishReason: Promise<FinishReason>;
+  readonly usage: Promise<LanguageModelUsage>;
+  readonly response: Promise<LanguageModelResponseMetadata>;
+  toUIMessageStream(): AsyncIterableStream<UIMessageChunk>;
+  toUIMessageStreamResponse(init?: ResponseInit): Response;
+  consumeStream(): Promise<void>;
+}
+
+export interface GenerateTextResult<TOOLS extends ToolSet> {
+  readonly text: string;
+  readonly finishReason: FinishReason;
+  readonly usage: LanguageModelUsage;
+  readonly response: LanguageModelResponseMetadata;
+  readonly toolCalls: TypedToolCall<TOOLS>[];
+  readonly toolResults: Array<TypedToolResult<TOOLS> | TypedToolError<TOOLS>>;
+}
+
+export interface StreamObjectResult<T> {
+  readonly partialObjectStream: AsyncIterableStream<Partial<T>>;
+  readonly object: Promise<T>;
+  readonly text: Promise<string>;
+  readonly finishReason: Promise<FinishReason>;
+}
+
+export interface StreamTextOptions<TOOLS extends ToolSet> {
+  readonly model: HarnessAnthropicModel;
+  readonly prompt?: string;
+  readonly messages?: ModelMessage[];
+  readonly system?: string;
+  readonly tools?: TOOLS;
+  readonly maxOutputTokens?: number;
+  readonly temperature?: number;
+  readonly topP?: number;
+  readonly stopSequences?: string[];
+  readonly includeRawChunks?: boolean;
+  readonly abortSignal?: AbortSignal;
+  readonly maxToolRoundtrips?: number;
+}
+
+export interface GenerateTextOptions<TOOLS extends ToolSet> extends StreamTextOptions<TOOLS> {}
+
+export interface StreamObjectOptions<T, TOOLS extends ToolSet> extends StreamTextOptions<TOOLS> {
+  readonly schema: JsonSchema;
+  readonly validate?: (value: unknown) => value is T;
+}

package/packages/harness-ai/src/ui-stream.ts

@@ -0,0 +1,217 @@
+import type { AsyncIterableStream, StreamTextPart, ToolSet, UIMessageChunk } from './types.ts';
+import { toAsyncIterableStream } from './async-iterable-stream.ts';
+
+export const UI_MESSAGE_STREAM_HEADERS: Readonly<Record<string, string>> = {
+  'content-type': 'text/event-stream',
+  'cache-control': 'no-cache',
+  connection: 'keep-alive',
+  'x-vercel-ai-ui-message-stream': 'v1',
+  'x-accel-buffering': 'no',
+};
+
+export class JsonToSseTransformStream extends TransformStream<unknown, string> {
+  constructor() {
+    super({
+      transform(part, controller) {
+        controller.enqueue(`data: ${JSON.stringify(part)}\n\n`);
+      },
+      flush(controller) {
+        controller.enqueue('data: [DONE]\n\n');
+      },
+    });
+  }
+}
+
+function defaultErrorText(error: unknown): string {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+
+export function createUIMessageStream<TOOLS extends ToolSet>(
+  stream: ReadableStream<StreamTextPart<TOOLS>>,
+  onError: (error: unknown) => string = defaultErrorText,
+): AsyncIterableStream<UIMessageChunk> {
+  const uiStream = stream.pipeThrough(
+    new TransformStream<StreamTextPart<TOOLS>, UIMessageChunk>({
+      transform(part, controller) {
+        switch (part.type) {
+          case 'start':
+            controller.enqueue({ type: 'start' });
+            break;
+          case 'start-step':
+            controller.enqueue({ type: 'start-step' });
+            break;
+          case 'text-start':
+            controller.enqueue({
+              type: 'text-start',
+              id: part.id,
+              providerMetadata: part.providerMetadata,
+            });
+            break;
+          case 'text-delta':
+            controller.enqueue({
+              type: 'text-delta',
+              id: part.id,
+              delta: part.text,
+              providerMetadata: part.providerMetadata,
+            });
+            break;
+          case 'text-end':
+            controller.enqueue({
+              type: 'text-end',
+              id: part.id,
+              providerMetadata: part.providerMetadata,
+            });
+            break;
+          case 'reasoning-start':
+            controller.enqueue({
+              type: 'reasoning-start',
+              id: part.id,
+              providerMetadata: part.providerMetadata,
+            });
+            break;
+          case 'reasoning-delta':
+            controller.enqueue({
+              type: 'reasoning-delta',
+              id: part.id,
+              delta: part.text,
+              providerMetadata: part.providerMetadata,
+            });
+            break;
+          case 'reasoning-end':
+            controller.enqueue({
+              type: 'reasoning-end',
+              id: part.id,
+              providerMetadata: part.providerMetadata,
+            });
+            break;
+          case 'tool-input-start':
+            controller.enqueue({
+              type: 'tool-input-start',
+              toolCallId: part.id,
+              toolName: part.toolName,
+              providerExecuted: part.providerExecuted,
+              providerMetadata: part.providerMetadata,
+              dynamic: part.dynamic,
+              title: part.title,
+            });
+            break;
+          case 'tool-input-delta':
+            controller.enqueue({
+              type: 'tool-input-delta',
+              toolCallId: part.id,
+              inputTextDelta: part.delta,
+            });
+            break;
+          case 'tool-call':
+            if (part.invalid) {
+              controller.enqueue({
+                type: 'tool-input-error',
+                toolCallId: part.toolCallId,
+                toolName: part.toolName,
+                input: part.input,
+                providerExecuted: part.providerExecuted,
+                providerMetadata: part.providerMetadata,
+                dynamic: part.dynamic,
+                title: part.title,
+                errorText: part.error ?? 'Invalid tool call',
+              });
+            } else {
+              controller.enqueue({
+                type: 'tool-input-available',
+                toolCallId: part.toolCallId,
+                toolName: part.toolName,
+                input: part.input,
+                providerExecuted: part.providerExecuted,
+                providerMetadata: part.providerMetadata,
+                dynamic: part.dynamic,
+                title: part.title,
+              });
+            }
+            break;
+          case 'tool-result':
+            controller.enqueue({
+              type: 'tool-output-available',
+              toolCallId: part.toolCallId,
+              output: part.output,
+              providerExecuted: part.providerExecuted,
+              dynamic: part.dynamic,
+              preliminary: part.preliminary,
+            });
+            break;
+          case 'tool-error':
+            controller.enqueue({
+              type: 'tool-output-error',
+              toolCallId: part.toolCallId,
+              providerExecuted: part.providerExecuted,
+              dynamic: part.dynamic,
+              errorText: onError(part.error),
+            });
+            break;
+          case 'source':
+            if (part.sourceType === 'url') {
+              controller.enqueue({
+                type: 'source-url',
+                sourceId: part.id,
+                url: part.url,
+                title: part.title,
+                providerMetadata: part.providerMetadata,
+              });
+            } else {
+              controller.enqueue({
+                type: 'source-document',
+                sourceId: part.id,
+                mediaType: part.mediaType,
+                title: part.title,
+                filename: part.filename,
+                providerMetadata: part.providerMetadata,
+              });
+            }
+            break;
+          case 'finish-step':
+            controller.enqueue({ type: 'finish-step' });
+            break;
+          case 'finish':
+            controller.enqueue({ type: 'finish', finishReason: part.finishReason });
+            break;
+          case 'abort':
+            controller.enqueue({ type: 'abort', reason: part.reason });
+            break;
+          case 'error':
+            controller.enqueue({ type: 'error', errorText: onError(part.error) });
+            break;
+          case 'raw':
+          case 'tool-input-end':
+            break;
+          default: {
+            const exhaustiveCheck: never = part;
+            throw new Error(`unhandled stream part: ${JSON.stringify(exhaustiveCheck)}`);
+          }
+        }
+      },
+    }),
+  );
+
+  return toAsyncIterableStream(uiStream);
+}
+
+export function createUIMessageStreamResponse(
+  stream: ReadableStream<UIMessageChunk>,
+  init?: ResponseInit,
+): Response {
+  const sseStream = stream
+    .pipeThrough(new JsonToSseTransformStream())
+    .pipeThrough(new TextEncoderStream());
+  const headers = new Headers(init?.headers ?? {});
+  for (const [key, value] of Object.entries(UI_MESSAGE_STREAM_HEADERS)) {
+    if (!headers.has(key)) {
+      headers.set(key, value);
+    }
+  }
+  return new Response(sseStream, {
+    ...init,
+    headers,
+  });
+}