@jmoyers/harness 0.1.8 → 0.1.10

package/packages/harness-ai/src/async-iterable-stream.ts

@@ -0,0 +1,65 @@
+import type { AsyncIterableStream } from './types.ts';
+
+export function toAsyncIterableStream<T>(stream: ReadableStream<T>): AsyncIterableStream<T> {
+  const candidate = stream as AsyncIterableStream<T>;
+  if (typeof candidate[Symbol.asyncIterator] === 'function') {
+    return candidate;
+  }
+
+  Object.defineProperty(candidate, Symbol.asyncIterator, {
+    configurable: true,
+    enumerable: false,
+    writable: false,
+    value: async function* iterator(): AsyncGenerator<T, void, unknown> {
+      const reader = stream.getReader();
+      try {
+        while (true) {
+          const { value, done } = await reader.read();
+          if (done) {
+            break;
+          }
+          if (value !== undefined) {
+            yield value;
+          }
+        }
+      } finally {
+        reader.releaseLock();
+      }
+    },
+  });
+
+  return candidate;
+}
+
+export async function consumeReadableStream<T>(stream: ReadableStream<T>): Promise<void> {
+  const reader = stream.getReader();
+  try {
+    while (true) {
+      const { done } = await reader.read();
+      if (done) {
+        break;
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+
+export async function collectReadableStream<T>(stream: ReadableStream<T>): Promise<T[]> {
+  const output: T[] = [];
+  const reader = stream.getReader();
+  try {
+    while (true) {
+      const { value, done } = await reader.read();
+      if (done) {
+        break;
+      }
+      if (value !== undefined) {
+        output.push(value);
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  return output;
+}

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

@@ -0,0 +1,36 @@
+export { createAnthropic, anthropic, anthropicTools } from './anthropic-provider.ts';
+export { streamText, generateText, collectFullStream } from './stream-text.ts';
+export { streamObject } from './stream-object.ts';
+export {
+  createUIMessageStream,
+  createUIMessageStreamResponse,
+  JsonToSseTransformStream,
+  UI_MESSAGE_STREAM_HEADERS,
+} from './ui-stream.ts';
+export type {
+  AnthropicProviderToolDefinition,
+  AssistantModelMessage,
+  AsyncIterableStream,
+  FinishReason,
+  FunctionToolDefinition,
+  GenerateTextOptions,
+  GenerateTextResult,
+  HarnessAnthropicModel,
+  JsonSchema,
+  JsonValue,
+  LanguageModelResponseMetadata,
+  LanguageModelUsage,
+  ModelMessage,
+  StreamObjectOptions,
+  StreamObjectResult,
+  StreamTextOptions,
+  StreamTextPart,
+  StreamTextResult,
+  ToolDefinition,
+  ToolSet,
+  TypedToolCall,
+  TypedToolError,
+  TypedToolResult,
+  UIMessageChunk,
+} from './types.ts';
+export type { AnthropicModelFactory, CreateAnthropicOptions } from './anthropic-provider.ts';

package/packages/harness-ai/src/json-parse.ts

@@ -0,0 +1,66 @@
+export function safeJsonParse(text: string): unknown | undefined {
+  try {
+    return JSON.parse(text) as unknown;
+  } catch {
+    return undefined;
+  }
+}
+
+export function extractFirstBalancedJsonObject(text: string): string | undefined {
+  const start = text.indexOf('{');
+  if (start < 0) {
+    return undefined;
+  }
+
+  let depth = 0;
+  let inString = false;
+  let escaping = false;
+
+  for (let index = start; index < text.length; index += 1) {
+    const char = text[index];
+    if (char === undefined) {
+      continue;
+    }
+
+    if (escaping) {
+      escaping = false;
+      continue;
+    }
+
+    if (char === '\\') {
+      escaping = true;
+      continue;
+    }
+
+    if (char === '"') {
+      inString = !inString;
+      continue;
+    }
+
+    if (inString) {
+      continue;
+    }
+
+    if (char === '{') {
+      depth += 1;
+      continue;
+    }
+
+    if (char === '}') {
+      depth -= 1;
+      if (depth === 0) {
+        return text.slice(start, index + 1);
+      }
+    }
+  }
+
+  return undefined;
+}
+
+export function parseJsonObjectFromText(text: string): unknown | undefined {
+  const objectSlice = extractFirstBalancedJsonObject(text);
+  if (objectSlice === undefined) {
+    return undefined;
+  }
+  return safeJsonParse(objectSlice);
+}

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

@@ -0,0 +1,80 @@
+interface SseEvent {
+  readonly event: string;
+  readonly data: string;
+}
+
+export function parseSseEventBlock(block: string): SseEvent | null {
+  const lines = block.split('\n');
+  let eventName = 'message';
+  const dataLines: string[] = [];
+
+  for (const line of lines) {
+    if (line.startsWith(':')) {
+      continue;
+    }
+    if (line.startsWith('event:')) {
+      eventName = line.slice('event:'.length).trim() || 'message';
+      continue;
+    }
+    if (line.startsWith('data:')) {
+      dataLines.push(line.slice('data:'.length).trimStart());
+    }
+  }
+
+  if (dataLines.length === 0) {
+    return null;
+  }
+
+  return {
+    event: eventName,
+    data: dataLines.join('\n'),
+  };
+}
+
+export function createSseEventStream(input: ReadableStream<Uint8Array>): ReadableStream<SseEvent> {
+  return new ReadableStream<SseEvent>({
+    async start(controller) {
+      const decoder = new TextDecoder();
+      const reader = input.getReader();
+      let buffer = '';
+
+      try {
+        while (true) {
+          const { value, done } = await reader.read();
+          if (done) {
+            break;
+          }
+          if (value === undefined) {
+            continue;
+          }
+
+          buffer += decoder.decode(value, { stream: true });
+          while (true) {
+            const boundary = buffer.indexOf('\n\n');
+            if (boundary < 0) {
+              break;
+            }
+            const block = buffer.slice(0, boundary);
+            buffer = buffer.slice(boundary + 2);
+            const parsed = parseSseEventBlock(block);
+            if (parsed !== null) {
+              controller.enqueue(parsed);
+            }
+          }
+        }
+
+        buffer += decoder.decode();
+        const tail = parseSseEventBlock(buffer);
+        if (tail !== null) {
+          controller.enqueue(tail);
+        }
+
+        controller.close();
+      } catch (error) {
+        controller.error(error);
+      } finally {
+        reader.releaseLock();
+      }
+    },
+  });
+}

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

@@ -0,0 +1,96 @@
+import { toAsyncIterableStream } from './async-iterable-stream.ts';
+import { parseJsonObjectFromText } from './json-parse.ts';
+import { streamText } from './stream-text.ts';
+import type {
+  StreamObjectOptions,
+  StreamObjectResult,
+  StreamTextOptions,
+  ToolSet,
+} from './types.ts';
+
+function buildJsonInstruction(schema: Record<string, unknown>): string {
+  return [
+    'Respond with strict JSON only.',
+    'Do not include markdown fences or extra commentary.',
+    `JSON schema: ${JSON.stringify(schema)}`,
+  ].join(' ');
+}
+
+function withObjectInstruction<T, TOOLS extends ToolSet>(
+  options: StreamObjectOptions<T, TOOLS>,
+): StreamTextOptions<TOOLS> {
+  const instruction = buildJsonInstruction(options.schema);
+
+  if (options.prompt !== undefined) {
+    return {
+      ...options,
+      prompt: `${options.prompt}\n\n${instruction}`,
+    };
+  }
+
+  const messages = options.messages ?? [];
+  return {
+    ...options,
+    messages,
+    system: options.system !== undefined ? `${options.system}\n\n${instruction}` : instruction,
+  };
+}
+
+export function streamObject<T, TOOLS extends ToolSet>(
+  options: StreamObjectOptions<T, TOOLS>,
+): StreamObjectResult<T> {
+  const result = streamText(withObjectInstruction(options));
+
+  let assembledText = '';
+  let lastJsonSnapshot = '';
+
+  const partialObjectStream = toAsyncIterableStream(
+    result.fullStream.pipeThrough(
+      new TransformStream({
+        transform(part, controller) {
+          if (part.type !== 'text-delta') {
+            return;
+          }
+
+          assembledText += part.text;
+          const maybeObject = parseJsonObjectFromText(assembledText);
+          if (
+            maybeObject === undefined ||
+            typeof maybeObject !== 'object' ||
+            maybeObject === null
+          ) {
+            return;
+          }
+
+          const serialized = JSON.stringify(maybeObject);
+          if (serialized === lastJsonSnapshot) {
+            return;
+          }
+
+          lastJsonSnapshot = serialized;
+          controller.enqueue(maybeObject as Partial<T>);
+        },
+      }),
+    ),
+  );
+
+  const object = result.text.then((text) => {
+    const parsed = parseJsonObjectFromText(text);
+    if (parsed === undefined) {
+      throw new Error('streamObject failed: no JSON object found in model output');
+    }
+
+    if (options.validate !== undefined && !options.validate(parsed)) {
+      throw new Error('streamObject failed: parsed JSON did not pass validator');
+    }
+
+    return parsed as T;
+  });
+
+  return {
+    partialObjectStream,
+    object,
+    text: result.text,
+    finishReason: result.finishReason,
+  };
+}