@opencode-ai/simulation 0.0.0-dev-17880

package/dist/backend/index.d.ts

@@ -0,0 +1,17 @@
+import { LayerNode } from "@opencode-ai/util/effect/layer-node";
+import { Effect, FileSystem } from "effect";
+/**
+ * Layer replacements applied when the server is built in simulation mode.
+ *
+ * The server merges these into the app node build when simulation is enabled
+ * is enabled, via a dynamic import so this module is never loaded eagerly.
+ *
+ * - Network: all outbound HTTP resolves against the simulated route table;
+ *   unknown destinations are denied. The driver-answered OpenAI endpoint is
+ *   registered here as the first route.
+ *
+ */
+export declare const simulationReplacements: (app: {
+    readonly version: string;
+}) => Effect.Effect<LayerNode.Replacements, Error, FileSystem.FileSystem>;
+export * as Simulation from "./index";

package/dist/backend/index.js

@@ -0,0 +1,29 @@
+import { LayerNode } from "@opencode-ai/util/effect/layer-node";
+import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
+import { httpClient } from "@opencode-ai/util/effect/app-node-platform";
+import { SdkPlugins } from "@opencode-ai/core/plugin/sdk";
+import { Config, Effect, FileSystem, Layer } from "effect";
+import { HttpClient } from "effect/unstable/http";
+import { DriveManifest } from "../manifest";
+import { SimulationNetwork } from "./network";
+import { SimulationOpenAI } from "./openai";
+import { SimulatedProvider } from "./simulated-provider";
+export const simulationReplacements = Effect.fn("Simulation.replacements")(function* (app) {
+  const models = SimulationNetwork.json("GET", "https://models.opencode.ai/api.json", {});
+  if (!(yield* Config.string("OPENCODE_DRIVE").pipe(Config.withDefault(void 0))))
+    return [[httpClient, SimulationNetwork.layer([models])]];
+  const manifest = yield* DriveManifest.resolve(), networkLayer = Layer.effect(HttpClient.HttpClient, Effect.gen(function* () {
+    const provider = yield* SimulatedProvider.Service;
+    return (yield* SimulationNetwork.make([SimulationOpenAI.route(provider), models])).client;
+  })).pipe(Layer.provide(SimulatedProvider.layerDrive({
+    endpoint: manifest.endpoints.backend,
+    version: app.version
+  }))), networkNode = makeGlobalNode({
+    service: HttpClient.HttpClient,
+    layer: networkLayer,
+    deps: [SdkPlugins.node]
+  });
+  return [[httpClient, networkNode]];
+});
+
+export * as Simulation from "./index";

package/dist/backend/network.d.ts

@@ -0,0 +1,33 @@
+import { Effect, Layer } from "effect";
+import { HttpClient, HttpClientResponse, type HttpMethod } from "effect/unstable/http";
+import { HttpClientError } from "effect/unstable/http/HttpClientError";
+import type { HttpClientRequest } from "effect/unstable/http";
+import { SimulationProtocol } from "../protocol";
+/**
+ * Simulated network.
+ *
+ * Replaces the `HttpClient.HttpClient` platform node in simulation mode. All
+ * outbound HTTP resolves against an in-memory route table; unknown
+ * destinations fail loudly with a transport error so no simulation run can
+ * silently reach the real network. The scripted LLM is one registered route,
+ * not a separate mechanism.
+ *
+ * Each acquired run owns its routes and request log.
+ */
+export interface Route {
+    /** Return a response effect to claim the request, undefined to pass. */
+    readonly match: (request: HttpClientRequest.HttpClientRequest, url: URL) => Effect.Effect<HttpClientResponse.HttpClientResponse, HttpClientError> | undefined;
+}
+export type LogEntry = SimulationProtocol.Backend.NetworkLogEntry;
+/** Static JSON route: exact method + origin/path match answered with a fixed body. */
+export declare function json(method: HttpMethod.HttpMethod, url: string, body: unknown): Route;
+export interface Run {
+    readonly client: HttpClient.HttpClient;
+    readonly log: () => Effect.Effect<readonly LogEntry[]>;
+}
+export declare const make: (routes?: readonly Route[] | undefined) => Effect.Effect<{
+    client: HttpClient.HttpClient;
+    log: () => Effect.Effect<readonly SimulationProtocol.Backend.NetworkLogEntry[], never, never>;
+}, never, never>;
+export declare const layer: (routes?: readonly Route[]) => Layer.Layer<HttpClient.HttpClient, never, never>;
+export * as SimulationNetwork from "./network";

package/dist/backend/network.js

@@ -0,0 +1,44 @@
+import { Clock, Effect, Layer, Ref } from "effect";
+import { HttpClient, HttpClientResponse } from "effect/unstable/http";
+import { HttpClientError, TransportError } from "effect/unstable/http/HttpClientError";
+import { SimulationProtocol } from "../protocol";
+const LOG_LIMIT = 1000;
+export function json(method, url, body) {
+  return {
+    match: (request, requestUrl) => {
+      if (request.method !== method)
+        return;
+      if (requestUrl.origin + requestUrl.pathname !== url)
+        return;
+      return Effect.sync(() => HttpClientResponse.fromWeb(request, new Response(JSON.stringify(body), { status: 200, headers: { "content-type": "application/json" } })));
+    }
+  };
+}
+export const make = Effect.fn("SimulationNetwork.make")(function* (routes = []) {
+  const log = yield* Ref.make([]);
+  return { client: HttpClient.make((request, url) => Effect.gen(function* () {
+    let matched;
+    for (const route of routes) {
+      matched = route.match(request, url);
+      if (matched)
+        break;
+    }
+    const entry = {
+      time: yield* Clock.currentTimeMillis,
+      method: request.method,
+      url: url.toString(),
+      matched: matched !== void 0
+    };
+    yield* Ref.update(log, (entries) => [...entries, entry].slice(-LOG_LIMIT));
+    if (matched)
+      return yield* matched;
+    return yield* Effect.fail(new HttpClientError({
+      reason: new TransportError({
+        request,
+        description: `Simulation denied unregistered network destination: ${request.method} ${url}`
+      })
+    }));
+  })), log: () => Ref.get(log) };
+}), layer = (routes = []) => Layer.effect(HttpClient.HttpClient, make(routes).pipe(Effect.map((run) => run.client)));
+
+export * as SimulationNetwork from "./network";

package/dist/backend/openai.d.ts

@@ -0,0 +1,4 @@
+import { SimulationNetwork } from "./network";
+import { SimulatedProvider } from "./simulated-provider";
+export declare const route: (provider: SimulatedProvider.Interface) => SimulationNetwork.Route;
+export * as SimulationOpenAI from "./openai";

package/dist/backend/openai.js

@@ -0,0 +1,101 @@
+import { Effect, Schema, Stream } from "effect";
+import { HttpClientResponse } from "effect/unstable/http";
+import { HttpClientError, TransportError } from "effect/unstable/http/HttpClientError";
+import { OpenAIChatEvent, DEFAULT_BASE_URL, PATH } from "@opencode-ai/ai/protocols/openai-chat";
+import { SimulationNetwork } from "./network";
+import { SimulatedProvider } from "./simulated-provider";
+const encodeChunk = Schema.encodeUnknownSync(OpenAIChatEvent), encoder = new TextEncoder, decodeBody = Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Json));
+function chunkOf(item) {
+  if (item.type === "textDelta")
+    return { choices: [{ delta: { content: item.text } }] };
+  if (item.type === "reasoningDelta")
+    return { choices: [{ delta: { reasoning_content: item.text } }] };
+  if (item.type === "toolInputStart")
+    return {
+      choices: [
+        {
+          delta: {
+            tool_calls: [
+              {
+                index: item.index,
+                id: item.id,
+                function: { name: item.name, arguments: "" }
+              }
+            ]
+          }
+        }
+      ]
+    };
+  if (item.type === "toolInputDelta")
+    return {
+      choices: [
+        {
+          delta: {
+            tool_calls: [{ index: item.index, function: { arguments: item.text } }]
+          }
+        }
+      ]
+    };
+  if (item.type === "toolCall")
+    return {
+      choices: [
+        {
+          delta: {
+            tool_calls: [
+              {
+                index: item.index,
+                id: item.id,
+                function: { name: item.name, arguments: JSON.stringify(item.input) }
+              }
+            ]
+          }
+        }
+      ]
+    };
+  return item.chunk;
+}
+const finishReasonWire = {
+  stop: "stop",
+  "tool-calls": "tool_calls",
+  length: "length",
+  "content-filter": "content_filter"
+};
+function frame(payload) {
+  return encoder.encode(`data: ${JSON.stringify(payload)}
+
+`);
+}
+function sseBody(events) {
+  return events.pipe(Stream.map((event) => {
+    if (event.type === "finish")
+      return frame(encodeChunk({ choices: [{ delta: {}, finish_reason: finishReasonWire[event.reason] }] }));
+    if (event.type === "raw")
+      return frame(event.chunk);
+    return frame(encodeChunk(chunkOf(event)));
+  }), Stream.concat(Stream.make(encoder.encode(`data: [DONE]
+
+`))));
+}
+export const route = (provider) => ({
+  match: (request, url) => {
+    if (request.method !== "POST")
+      return;
+    if (url.origin + url.pathname !== DEFAULT_BASE_URL + PATH)
+      return;
+    return Effect.gen(function* () {
+      const body = request.body._tag === "Uint8Array" ? yield* decodeBody(new TextDecoder().decode(request.body.body)).pipe(Effect.mapError((cause) => new HttpClientError({
+        reason: new TransportError({
+          request,
+          cause,
+          description: "Simulation received an invalid OpenAI request body"
+        })
+      }))) : {};
+      return HttpClientResponse.fromWeb(request, new Response(Stream.toReadableStream(sseBody(provider.stream({ url: url.toString(), body }))), {
+        status: 200,
+        headers: { "content-type": "text/event-stream" }
+      }));
+    });
+  }
+});
+
+export * as SimulationOpenAI from "./openai";

package/dist/backend/simulated-provider.d.ts

@@ -0,0 +1,27 @@
+import { SdkPlugins } from "@opencode-ai/core/plugin/sdk";
+import { Cause, Context, Layer, Schema, Stream } from "effect";
+import { SimulationProtocol } from "../protocol";
+export interface ProviderRequest {
+    readonly url: string;
+    readonly body: unknown;
+}
+export type ProviderResponseEvent = SimulationProtocol.Backend.Item | {
+    readonly type: "finish";
+    readonly reason: SimulationProtocol.Backend.FinishReason;
+};
+declare const ProviderDisconnectedError_base: Schema.Class<ProviderDisconnectedError, Schema.TaggedStruct<"SimulatedProvider.ProviderDisconnectedError", {
+    readonly message: Schema.String;
+}>, Cause.YieldableError>;
+export declare class ProviderDisconnectedError extends ProviderDisconnectedError_base {
+}
+export interface Interface {
+    readonly stream: (request: ProviderRequest) => Stream.Stream<ProviderResponseEvent, ProviderDisconnectedError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/simulation/SimulatedProvider", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const layerDrive: (options: {
+    readonly endpoint: string;
+    readonly version: string;
+}) => Layer.Layer<Service, unknown, SdkPlugins.Service>;
+export * as SimulatedProvider from "./simulated-provider";