@frockbot/provider-openai-compatible 0.0.0 → 0.1.0

package/package.json

@@ -1,14 +1,31 @@
 {
   "name": "@frockbot/provider-openai-compatible",
-  "version": "0.0.0",
-  "description": "Placeholder reserving this name for trusted publishing. Superseded by the first release.",
-  "license": "UNLICENSED",
+  "version": "0.1.0",
+  "private": false,
+  "type": "module",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "scripts": {
+    "test": "bun test src",
+    "typecheck": "tsc --noEmit -p tsconfig.json"
+  },
+  "dependencies": {
+    "@frockbot/kernel-contracts": "0.1.0",
+    "@frockbot/plugin-models": "0.1.0",
+    "cordis": "4.0.0-rc.8"
+  },
+  "devDependencies": {
+    "@types/bun": "1.4.0",
+    "@types/node": "26.2.0",
+    "typescript": "^7.0.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/timoconnellaus/frockbot.git",
     "directory": "packages/provider-openai-compatible"
-  },
-  "publishConfig": {
-    "access": "public"
   }
 }

package/src/index.test.ts

@@ -0,0 +1,361 @@
+import { describe, expect, test } from "bun:test";
+import { type NormalizedModelRequest } from "@frockbot/kernel-contracts";
+import { LlmRegistry } from "@frockbot/plugin-models";
+import { Context } from "cordis";
+import { OpenAICompatibleProvider, requestToWire } from "./index.js";
+
+const request: NormalizedModelRequest = {
+  requestId: "request-1",
+  provider: "openai-compatible",
+  model: "test-model",
+  system: "Be useful.",
+  messages: [
+    { role: "user", content: "What time is it?" },
+    {
+      role: "assistant",
+      content: "",
+      toolCalls: [{ id: "previous", name: "lookup", input: { query: "time" } }],
+    },
+    {
+      role: "tool",
+      callId: "previous",
+      name: "lookup",
+      content: "noon",
+      isError: false,
+    },
+  ],
+  tools: [
+    {
+      name: "current_time",
+      description: "Return the time.",
+      inputSchema: { type: "object", properties: {} },
+    },
+  ],
+};
+
+describe("OpenAICompatibleProvider", () => {
+  test("normalizes FrockBot messages and tools to the wire format", () => {
+    expect(requestToWire(request)).toMatchObject({
+      model: "test-model",
+      stream: true,
+      messages: [
+        { role: "system", content: "Be useful." },
+        { role: "user", content: "What time is it?" },
+        {
+          role: "assistant",
+          tool_calls: [
+            {
+              id: "previous",
+              type: "function",
+              function: { name: "lookup", arguments: '{"query":"time"}' },
+            },
+          ],
+        },
+        { role: "tool", tool_call_id: "previous", content: "noon" },
+      ],
+      tools: [
+        {
+          type: "function",
+          function: { name: "current_time", description: "Return the time." },
+        },
+      ],
+    });
+  });
+
+  test("streams text and assembles fragmented tool calls", async () => {
+    const encoder = new TextEncoder();
+    const payloads = [
+      'data: {"choices":[{"delta":{"content":"Checking "}}]}\n\n',
+      'data: {"choices":[{"delta":{"tool_calls":[{"index":0,"id":"call-1","function":{"name":"current_","arguments":"{\\"zone\\":"}}]}}]}\n\n',
+      'data: {"choices":[{"delta":{"tool_calls":[{"index":0,"function":{"name":"time","arguments":"\\"UTC\\"}"}}]},"finish_reason":"tool_calls"}]}\n\n',
+      "data: [DONE]\n\n",
+    ];
+    let capturedUrl = "";
+    let capturedAuthorization = "";
+    let capturedIdempotencyKey: string | null = null;
+    const fetcher = async (
+      input: string | URL | Request,
+      init?: RequestInit,
+    ) => {
+      capturedUrl = String(input);
+      capturedAuthorization =
+        new Headers(init?.headers).get("authorization") ?? "";
+      capturedIdempotencyKey = new Headers(init?.headers).get(
+        "idempotency-key",
+      );
+      return new Response(
+        new ReadableStream<Uint8Array>({
+          start(controller) {
+            for (const payload of payloads)
+              controller.enqueue(encoder.encode(payload));
+            controller.close();
+          },
+        }),
+        { status: 200 },
+      );
+    };
+    const provider = new OpenAICompatibleProvider({
+      baseUrl: "https://models.example/v1/",
+      apiKey: "secret",
+      fetch: fetcher,
+    });
+
+    const events = [];
+    for await (const event of provider.stream(
+      request,
+      new AbortController().signal,
+    )) {
+      events.push(event);
+    }
+
+    expect(capturedUrl).toBe("https://models.example/v1/chat/completions");
+    expect(capturedAuthorization).toBe("Bearer secret");
+    expect(capturedIdempotencyKey).toBeNull();
+    expect(events).toEqual([
+      { type: "text-delta", text: "Checking " },
+      {
+        type: "tool-call",
+        call: {
+          id: "call-1",
+          name: "current_time",
+          input: { zone: "UTC" },
+        },
+      },
+      { type: "finish", reason: "tool-calls" },
+    ]);
+  });
+
+  test("rejects a truncated stream without a terminal marker", async () => {
+    const provider = new OpenAICompatibleProvider({
+      baseUrl: "https://models.example/v1",
+      fetch: () =>
+        Promise.resolve(
+          new Response(
+            'data: {"choices":[{"delta":{"content":"partial"}}]}\n\n',
+            { status: 200 },
+          ),
+        ),
+    });
+    const events = [];
+    let failure: unknown;
+
+    try {
+      for await (const event of provider.stream(
+        request,
+        new AbortController().signal,
+      )) {
+        events.push(event);
+      }
+    } catch (error) {
+      failure = error;
+    }
+
+    expect(events).toEqual([{ type: "text-delta", text: "partial" }]);
+    expect(failure).toBeInstanceOf(Error);
+    expect(failure instanceof Error ? failure.message : "").toBe(
+      "Model response stream ended before a terminal marker",
+    );
+  });
+
+  test.each([
+    "data: [DONE]\n\n",
+    'data: {"model":"test-model"}\n\ndata: [DONE]\n\n',
+  ])("rejects a terminal stream without a choice", async (body) => {
+    const provider = new OpenAICompatibleProvider({
+      baseUrl: "https://models.example/v1",
+      fetch: () => Promise.resolve(new Response(body, { status: 200 })),
+    });
+
+    let failure: unknown;
+    try {
+      for await (const _event of provider.stream(
+        request,
+        new AbortController().signal,
+      )) {
+        throw new Error("unexpected stream event");
+      }
+    } catch (error) {
+      failure = error;
+    }
+
+    expect(failure instanceof Error ? failure.message : "").toBe(
+      "Model response stream did not include a valid choice",
+    );
+  });
+
+  test("cancels an oversized unterminated stream", async () => {
+    const encoder = new TextEncoder();
+    let cancelled = false;
+    const provider = new OpenAICompatibleProvider({
+      baseUrl: "https://models.example/v1",
+      fetch: () =>
+        Promise.resolve(
+          new Response(
+            new ReadableStream<Uint8Array>({
+              start(controller) {
+                controller.enqueue(
+                  encoder.encode(`data: ${"x".repeat(1_048_577)}`),
+                );
+              },
+              cancel() {
+                cancelled = true;
+              },
+            }),
+            { status: 200 },
+          ),
+        ),
+    });
+
+    let failure: unknown;
+    try {
+      for await (const _event of provider.stream(
+        request,
+        new AbortController().signal,
+      )) {
+        throw new Error("unexpected stream event");
+      }
+    } catch (error) {
+      failure = error;
+    }
+
+    expect(failure instanceof Error ? failure.message : "").toBe(
+      "Model response stream exceeded its size limit",
+    );
+    expect(cancelled).toBe(true);
+  });
+
+  test("reports retrieval unavailable without another provider request", async () => {
+    let requests = 0;
+    const provider = new OpenAICompatibleProvider({
+      baseUrl: "https://models.example/v1",
+      fetch: () => {
+        requests += 1;
+        return Promise.resolve(new Response(null, { status: 500 }));
+      },
+    });
+    const root = new Context();
+    await root.plugin(LlmRegistry);
+    root.llm.register(provider);
+
+    const outcome = await root.llm.reconcile(
+      request,
+      new AbortController().signal,
+    );
+
+    expect(outcome).toEqual({
+      status: "unavailable",
+      reason:
+        'LLM provider "openai-compatible" does not support provider-bound retrieval',
+    });
+    expect(requests).toBe(0);
+    await root.fiber.dispose();
+  });
+
+  test("redacts provider response bodies from HTTP errors", async () => {
+    const provider = new OpenAICompatibleProvider({
+      baseUrl: "https://models.example/v1",
+      fetch: () =>
+        Promise.resolve(new Response("bad credentials", { status: 401 })),
+    });
+
+    let failure: unknown;
+    try {
+      for await (const _event of provider.stream(
+        request,
+        new AbortController().signal,
+      )) {
+        // No events are expected from a failed response.
+      }
+    } catch (error) {
+      failure = error;
+    }
+    expect(failure instanceof Error ? failure.message : "").toBe(
+      "Model request failed (401)",
+    );
+  });
+});
+
+// An image a tool produced, on the wire.
+//
+// Two behaviours, and the difference between them has to be visible in the
+// request: a model that takes images is shown the picture, and a model that
+// does not is *told* where it is. Silently dropping it would make a Bot that
+// asked for a screenshot indistinguishable from one that got nothing.
+describe("tool result attachments", () => {
+  const attachment = {
+    kind: "image" as const,
+    mediaType: "image/png" as const,
+    workspacePath: {
+      root: {
+        kind: "package-declared" as const,
+        userId: "user-1",
+        packageId: "computer",
+        rootId: "screenshots",
+      },
+      path: "bot-1/run-9-1.png",
+    },
+    contentHash: "b".repeat(64),
+    bytes: 3,
+  };
+
+  function requestWith(model: string, dataBase64?: string) {
+    return {
+      requestId: "request-1",
+      provider: "openai-compatible",
+      model,
+      system: "",
+      tools: [],
+      messages: [
+        {
+          role: "tool" as const,
+          callId: "call-1",
+          name: "computer_screenshot",
+          content: '{"path":"bot-1/run-9-1.png"}',
+          isError: false,
+          attachments: [
+            { ...attachment, ...(dataBase64 ? { dataBase64 } : {}) },
+          ],
+        },
+      ],
+    };
+  }
+
+  test("shows a vision model the image as a following user message", () => {
+    const wire = requestToWire(requestWith("gpt-4o", "AAAA"));
+    const messages = wire.messages as Record<string, unknown>[];
+
+    expect(messages[0]).toMatchObject({ role: "tool", tool_call_id: "call-1" });
+    expect(messages[1]).toMatchObject({ role: "user" });
+    expect(JSON.stringify(messages[1])).toContain("data:image/png;base64,AAAA");
+  });
+
+  test("tells a model that takes no image where the image is", () => {
+    const wire = requestToWire(requestWith("llama3-8b", "AAAA"));
+    const messages = wire.messages as Record<string, unknown>[];
+
+    expect(messages).toHaveLength(1);
+    expect(messages[0]!.content).toContain("not shown to this model");
+    expect(messages[0]!.content).toContain("bot-1/run-9-1.png");
+    expect(JSON.stringify(wire)).not.toContain("AAAA");
+  });
+
+  test("says so when a vision model's image could not be resolved", () => {
+    const wire = requestToWire(requestWith("gpt-4o"));
+    const messages = wire.messages as Record<string, unknown>[];
+
+    expect(messages).toHaveLength(1);
+    expect(messages[0]!.content).toContain("not shown to this model");
+  });
+
+  test("lets an explicit acceptsImages override the model-name guess", () => {
+    const shown = requestToWire(requestWith("some-local-model", "AAAA"), {
+      acceptsImages: true,
+    });
+    expect((shown.messages as unknown[]).length).toBe(2);
+
+    const withheld = requestToWire(requestWith("gpt-4o", "AAAA"), {
+      acceptsImages: false,
+    });
+    expect((withheld.messages as unknown[]).length).toBe(1);
+  });
+});

package/src/index.ts

@@ -0,0 +1,396 @@
+import {
+  type LlmMessage,
+  type LlmProvider,
+  type LlmStreamEvent,
+  type NormalizedModelRequest,
+} from "@frockbot/kernel-contracts";
+import type { Plugin } from "cordis";
+
+export type JsonValue =
+  null | boolean | number | string | JsonValue[] | { [key: string]: JsonValue };
+
+export type FetchLike = (
+  input: string | URL | Request,
+  init?: RequestInit,
+) => Promise<Response>;
+
+export class OpenAICompatibleHttpError extends Error {
+  constructor(readonly status: number) {
+    super(`Model request failed (${status})`);
+    this.name = "OpenAICompatibleHttpError";
+  }
+}
+
+export interface OpenAICompatibleConfig {
+  baseUrl: string;
+  apiKey?: string;
+  providerId?: string;
+  headers?: Record<string, string>;
+  fetch?: FetchLike;
+  /**
+   * Whether this endpoint's model accepts image content. Absent, and the
+   * model id decides through {@link modelAcceptsImagesV1}.
+   */
+  acceptsImages?: boolean;
+}
+
+interface ToolAccumulator {
+  index: number;
+  id: string;
+  name: string;
+  arguments: string;
+}
+
+/**
+ * Model families this adapter will hand an image to.
+ *
+ * A guess, and named as one: there is no capability field on the wire and no
+ * catalog this adapter can consult, so the default is a list of families whose
+ * documented input includes images. `acceptsImages` overrides it in both
+ * directions, which is what a deployment that knows better sets.
+ */
+const VISION_MODEL_PATTERNS = [
+  /gpt-4o/i,
+  /gpt-4\.1/i,
+  /gpt-5/i,
+  /o[34]\b/i,
+  /claude-/i,
+  /gemini-/i,
+  /vision/i,
+  /-vl\b/i,
+  /llava/i,
+  /pixtral/i,
+  /internvl/i,
+];
+
+/** Whether this adapter will show `model` an image attachment. */
+export function modelAcceptsImagesV1(model: string): boolean {
+  return VISION_MODEL_PATTERNS.some((pattern) => pattern.test(model));
+}
+
+function dataUrl(mediaType: string, dataBase64: string): string {
+  return `data:${mediaType};base64,${dataBase64}`;
+}
+
+function messageToWire(
+  message: LlmMessage,
+  acceptsImages: boolean,
+): Record<string, unknown>[] {
+  if (message.role === "user")
+    return [{ role: "user", content: message.content }];
+  if (message.role === "tool") {
+    const attachments = message.attachments ?? [];
+    // An attachment this adapter cannot show is said in the text rather than
+    // dropped in silence: a Bot that asked for a screenshot has to be able to
+    // tell "the model saw it" from "the model was told where it is".
+    const shown = acceptsImages
+      ? attachments.filter((attachment) => attachment.dataBase64 !== undefined)
+      : [];
+    const withheld = attachments.filter(
+      (attachment) => !shown.includes(attachment),
+    );
+    const notes = withheld.map(
+      (attachment) =>
+        `[attachment ${attachment.mediaType} not shown to this model; it is at ${attachment.workspacePath.path} (sha256 ${attachment.contentHash})]`,
+    );
+    const tool = {
+      role: "tool",
+      tool_call_id: message.callId,
+      content: [message.content, ...notes].filter(Boolean).join("\n"),
+    };
+    if (shown.length === 0) return [tool];
+    // The image travels as a following user message rather than inside the
+    // tool result: an OpenAI-shaped `tool` message takes text, and a content
+    // array there is refused by the very endpoints that accept the image.
+    return [
+      tool,
+      {
+        role: "user",
+        content: [
+          {
+            type: "text",
+            text: `Attachments from ${message.name}:`,
+          },
+          ...shown.map((attachment) => ({
+            type: "image_url",
+            image_url: {
+              url: dataUrl(attachment.mediaType, attachment.dataBase64!),
+            },
+          })),
+        ],
+      },
+    ];
+  }
+  return [
+    {
+      role: "assistant",
+      content: message.content || null,
+      ...(message.toolCalls.length > 0
+        ? {
+            tool_calls: message.toolCalls.map((call) => ({
+              id: call.id,
+              type: "function",
+              function: {
+                name: call.name,
+                arguments: JSON.stringify(call.input),
+              },
+            })),
+          }
+        : {}),
+    },
+  ];
+}
+
+export function requestToWire(
+  request: NormalizedModelRequest,
+  options: { acceptsImages?: boolean } = {},
+): Record<string, unknown> {
+  const acceptsImages =
+    options.acceptsImages ?? modelAcceptsImagesV1(request.model);
+  const messages: Record<string, unknown>[] = [];
+  if (request.system)
+    messages.push({ role: "system", content: request.system });
+  for (const message of request.messages) {
+    messages.push(...messageToWire(message, acceptsImages));
+  }
+  return {
+    model: request.model,
+    stream: true,
+    messages,
+    ...(request.tools.length > 0
+      ? {
+          tools: request.tools.map((tool) => ({
+            type: "function",
+            function: {
+              name: tool.name,
+              description: tool.description,
+              parameters: tool.inputSchema,
+            },
+          })),
+        }
+      : {}),
+  };
+}
+
+const MAX_SSE_EVENT_CHARACTERS = 1_048_576;
+const MAX_SSE_RESPONSE_BYTES = 16_777_216;
+
+async function rejectOversizedSse(
+  reader: ReadableStreamDefaultReader<Uint8Array>,
+): Promise<never> {
+  await reader.cancel().catch(() => undefined);
+  throw new Error("Model response stream exceeded its size limit");
+}
+
+async function* readSseData(
+  body: ReadableStream<Uint8Array>,
+  signal: AbortSignal,
+): AsyncIterable<string> {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let responseBytes = 0;
+  const cancel = (): void => {
+    void reader.cancel(signal.reason).catch(() => undefined);
+  };
+  signal.addEventListener("abort", cancel, { once: true });
+  try {
+    signal.throwIfAborted();
+    while (true) {
+      const { done, value } = await reader.read();
+      signal.throwIfAborted();
+      responseBytes += value?.byteLength ?? 0;
+      if (responseBytes > MAX_SSE_RESPONSE_BYTES) {
+        await rejectOversizedSse(reader);
+      }
+      buffer += decoder.decode(value, { stream: !done });
+      const blocks = buffer.split(/\r?\n\r?\n/);
+      buffer = blocks.pop() ?? "";
+      if (
+        buffer.length > MAX_SSE_EVENT_CHARACTERS ||
+        blocks.some((block) => block.length > MAX_SSE_EVENT_CHARACTERS)
+      ) {
+        await rejectOversizedSse(reader);
+      }
+      for (const block of blocks) {
+        const data = block
+          .split(/\r?\n/)
+          .filter((line) => line.startsWith("data:"))
+          .map((line) => line.slice(5).trimStart())
+          .join("\n");
+        if (data) yield data;
+      }
+      if (done) break;
+    }
+    if (buffer.startsWith("data:")) yield buffer.slice(5).trimStart();
+  } finally {
+    signal.removeEventListener("abort", cancel);
+    reader.releaseLock();
+  }
+}
+
+function asRecord(value: unknown): Record<string, unknown> | undefined {
+  return typeof value === "object" && value !== null
+    ? (value as Record<string, unknown>)
+    : undefined;
+}
+
+function applyToolDeltas(
+  value: unknown,
+  tools: Map<number, ToolAccumulator>,
+): void {
+  if (!Array.isArray(value)) return;
+  for (const candidate of value) {
+    const delta = asRecord(candidate);
+    if (!delta || typeof delta.index !== "number") continue;
+    const current = tools.get(delta.index) ?? {
+      index: delta.index,
+      id: "",
+      name: "",
+      arguments: "",
+    };
+    if (typeof delta.id === "string") current.id = delta.id;
+    const fn = asRecord(delta.function);
+    if (typeof fn?.name === "string") current.name += fn.name;
+    if (typeof fn?.arguments === "string") current.arguments += fn.arguments;
+    tools.set(delta.index, current);
+  }
+}
+
+function parseJson(value: string, label: string): JsonValue {
+  try {
+    return JSON.parse(value) as JsonValue;
+  } catch (error) {
+    throw new Error(`${label}: ${String(error)}`);
+  }
+}
+
+function parseToolInput(value: string): JsonValue {
+  return value ? parseJson(value, "Model returned invalid tool arguments") : {};
+}
+
+/**
+ * Normalize an OpenAI-compatible SSE body. Native provider bindings can reuse
+ * this wire decoder without pretending their in-process call is HTTP.
+ */
+export async function* streamOpenAICompatibleBody(
+  body: ReadableStream<Uint8Array>,
+  signal: AbortSignal,
+): AsyncIterable<LlmStreamEvent> {
+  const tools = new Map<number, ToolAccumulator>();
+  let finishReason: string | undefined;
+  let terminal = false;
+  let sawChoice = false;
+  for await (const data of readSseData(body, signal)) {
+    if (data === "[DONE]") {
+      terminal = true;
+      break;
+    }
+    const payload = asRecord(
+      parseJson(data, "Model returned an invalid stream event"),
+    );
+    const choices = payload?.choices;
+    const choice = Array.isArray(choices) ? asRecord(choices[0]) : undefined;
+    const delta = asRecord(choice?.delta);
+    if (choice && (delta || typeof choice.finish_reason === "string")) {
+      sawChoice = true;
+    }
+    if (typeof delta?.content === "string" && delta.content) {
+      yield { type: "text-delta", text: delta.content };
+    }
+    applyToolDeltas(delta?.tool_calls, tools);
+    if (typeof choice?.finish_reason === "string") {
+      finishReason = choice.finish_reason;
+      terminal = true;
+    }
+  }
+  if (!terminal) {
+    throw new Error("Model response stream ended before a terminal marker");
+  }
+  if (!sawChoice) {
+    throw new Error("Model response stream did not include a valid choice");
+  }
+
+  for (const tool of [...tools.values()].sort(
+    (left, right) => left.index - right.index,
+  )) {
+    if (!tool.name)
+      throw new Error("Model returned a tool call without a name");
+    yield {
+      type: "tool-call",
+      call: {
+        id: tool.id || crypto.randomUUID(),
+        name: tool.name,
+        input: parseToolInput(tool.arguments),
+      },
+    };
+  }
+  yield {
+    type: "finish",
+    reason:
+      tools.size > 0 || finishReason === "tool_calls"
+        ? "tool-calls"
+        : finishReason === "length"
+          ? "max-tokens"
+          : "completed",
+  };
+}
+
+export class OpenAICompatibleProvider implements LlmProvider {
+  readonly id: string;
+  private config: OpenAICompatibleConfig;
+
+  constructor(config: OpenAICompatibleConfig) {
+    if (!config.baseUrl.trim())
+      throw new Error("OpenAI-compatible baseUrl is required");
+    this.id = config.providerId ?? "openai-compatible";
+    this.config = { ...config, baseUrl: config.baseUrl.replace(/\/$/, "") };
+  }
+
+  async *stream(
+    request: NormalizedModelRequest,
+    signal: AbortSignal,
+  ): AsyncIterable<LlmStreamEvent> {
+    // Workerd rejects a detached global `fetch` ("Illegal invocation"), so the
+    // default fetcher forwards through a closure rather than aliasing it.
+    const fetcher =
+      this.config.fetch ??
+      ((input: RequestInfo | URL, init?: RequestInit) =>
+        globalThis.fetch(input, init));
+    const headers: Record<string, string> = {
+      "content-type": "application/json",
+      ...this.config.headers,
+    };
+    if (this.config.apiKey)
+      headers.authorization = `Bearer ${this.config.apiKey}`;
+    const response = await fetcher(`${this.config.baseUrl}/chat/completions`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(
+        requestToWire(request, {
+          ...(this.config.acceptsImages === undefined
+            ? {}
+            : { acceptsImages: this.config.acceptsImages }),
+        }),
+      ),
+      signal,
+    });
+    if (!response.ok) {
+      await response.body?.cancel();
+      throw new OpenAICompatibleHttpError(response.status);
+    }
+    if (!response.body)
+      throw new Error("Model response did not include a stream");
+
+    yield* streamOpenAICompatibleBody(response.body, signal);
+  }
+}
+
+export function createOpenAICompatiblePlugin(
+  config: OpenAICompatibleConfig,
+): Plugin.Function {
+  const plugin: Plugin.Function = (ctx) =>
+    ctx.llm.register(new OpenAICompatibleProvider(config));
+  plugin.inject = ["llm"];
+  return plugin;
+}

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "ES2023",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "strict": true,
+    "noEmit": true,
+    "skipLibCheck": true,
+    "lib": ["ES2023", "DOM", "DOM.Iterable"],
+    "types": ["bun", "node"]
+  },
+  "include": ["src/**/*.ts"]
+}

package/README.md

@@ -1,3 +0,0 @@
-# @frockbot/provider-openai-compatible
-
-Placeholder reserving this name. See https://github.com/timoconnellaus/frockbot.