@homeflare/seat-runtime 0.1.0

package/dist/index.js

@@ -0,0 +1,508 @@
+import { createRequire } from "node:module";
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/seat-model.ts
+var exports_seat_model = {};
+__export(exports_seat_model, {
+  clientLayer: () => clientLayer,
+  embeddingLayer: () => embeddingLayer,
+  layer: () => layer2
+});
+import { OpenAiClient, OpenAiEmbeddingModel, OpenAiLanguageModel } from "@effect/ai-openai-compat";
+import * as Layer from "effect/Layer";
+import * as Redacted from "effect/Redacted";
+import * as EmbeddingModel from "effect/unstable/ai/EmbeddingModel";
+import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
+import * as HttpClient from "effect/unstable/http/HttpClient";
+
+// src/stamp.ts
+import * as HttpClientRequest from "effect/unstable/http/HttpClientRequest";
+var TAG = /^[\x21-\x2b\x2d-\x7e]{1,128}$/;
+function joinTags(tags) {
+  const list = typeof tags === "string" ? tags.split(",") : [...tags];
+  if (list.length === 0)
+    throw new TypeError("seat tags: at least one tag is required");
+  for (const tag of list) {
+    if (!TAG.test(tag)) {
+      throw new TypeError(`seat tags: ${JSON.stringify(tag)} is not a tag (1-128 printable ASCII, no comma or space)`);
+    }
+  }
+  return list.join(",");
+}
+function jsonObject(request) {
+  const body = request.body;
+  if (body._tag !== "Uint8Array" || !body.contentType.includes("json"))
+    return;
+  const text = body.text ?? new TextDecoder().decode(body.body);
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return;
+  }
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed))
+    return;
+  return parsed;
+}
+function stampRequest(request, stamp) {
+  const headers = stamp.noCache ? { "x-litellm-tags": stamp.tags, "cache-control": "no-cache, no-store" } : { "x-litellm-tags": stamp.tags };
+  const tagged = HttpClientRequest.setHeaders(request, headers);
+  const body = jsonObject(request);
+  if (body === undefined)
+    return tagged;
+  return HttpClientRequest.bodyJsonUnsafe(tagged, {
+    ...body,
+    ...stamp.noCache ? { cache: { "no-cache": true, "no-store": true } } : {},
+    num_retries: 0,
+    ...stamp.metadata !== undefined && !("metadata" in body) ? { metadata: stamp.metadata } : {}
+  });
+}
+
+// src/seat-model.ts
+function clientLayer(options) {
+  const stamp = {
+    tags: joinTags(options.tags),
+    noCache: options.noCache ?? true,
+    metadata: options.metadata
+  };
+  return OpenAiClient.layer({
+    apiKey: Redacted.isRedacted(options.apiKey) ? options.apiKey : Redacted.make(options.apiKey),
+    apiUrl: options.apiUrl.replace(/\/$/, ""),
+    transformClient: (http) => HttpClient.mapRequest(http, (request) => stampRequest(request, stamp))
+  }).pipe(Layer.provide(FetchHttpClient.layer));
+}
+function layer2(options) {
+  return OpenAiLanguageModel.layer({
+    model: options.model,
+    config: { strictJsonSchema: false, ...options.config }
+  }).pipe(Layer.provide(clientLayer(options)));
+}
+function embeddingLayer(options) {
+  return Layer.merge(OpenAiEmbeddingModel.layer({ model: options.model, config: options.config }), Layer.succeed(EmbeddingModel.Dimensions, options.dimensions)).pipe(Layer.provide(clientLayer(options)));
+}
+// src/seat-obs.ts
+var exports_seat_obs = {};
+__export(exports_seat_obs, {
+  CT100_ENDPOINTS: () => CT100_ENDPOINTS,
+  DEFAULT_SERVICE_NAME: () => DEFAULT_SERVICE_NAME,
+  layer: () => layer4
+});
+import * as Config from "effect/Config";
+import * as ConfigProvider from "effect/ConfigProvider";
+import * as Effect from "effect/Effect";
+import * as Layer2 from "effect/Layer";
+import * as Schema from "effect/Schema";
+import * as FetchHttpClient2 from "effect/unstable/http/FetchHttpClient";
+import {
+  OtlpLogger,
+  OtlpMetrics,
+  OtlpSerialization,
+  OtlpTracer
+} from "effect/unstable/observability";
+var CT100_ENDPOINTS = {
+  traces: "http://10.100.1.4:10428/insert/opentelemetry/v1/traces",
+  logs: "http://10.100.1.4:9428/insert/opentelemetry/v1/logs",
+  metrics: "http://10.100.1.4:8428/opentelemetry/v1/metrics"
+};
+var DEFAULT_SERVICE_NAME = "seat-runtime";
+var resourceAttributes = Config.Record(Schema.StringFromUriComponent, Schema.StringFromUriComponent, "OTEL_RESOURCE_ATTRIBUTES").pipe(Config.withDefault(undefined));
+var defaults = Effect.gen(function* () {
+  const current = yield* ConfigProvider.ConfigProvider;
+  const base = yield* current.load(["OTEL_EXPORTER_OTLP_ENDPOINT"]);
+  const attributes = yield* resourceAttributes.parse(current);
+  const named = attributes?.["service.name"] !== undefined;
+  return ConfigProvider.fromUnknown({
+    OTEL_TRACES_EXPORTER: "otlp",
+    OTEL_LOGS_EXPORTER: "otlp",
+    OTEL_METRICS_EXPORTER: "otlp",
+    ...named ? {} : { OTEL_SERVICE_NAME: DEFAULT_SERVICE_NAME },
+    ...base === undefined ? {
+      OTEL_EXPORTER_OTLP_TRACES_ENDPOINT: CT100_ENDPOINTS.traces,
+      OTEL_EXPORTER_OTLP_LOGS_ENDPOINT: CT100_ENDPOINTS.logs,
+      OTEL_EXPORTER_OTLP_METRICS_ENDPOINT: CT100_ENDPOINTS.metrics
+    } : {}
+  });
+}).pipe(Effect.orDie);
+var layer4 = Layer2.mergeAll(OtlpTracer.layerFromConfig(), OtlpLogger.layerFromConfig(), OtlpMetrics.layerFromConfig()).pipe(Layer2.provide(OtlpSerialization.layerProtobuf), Layer2.provide(FetchHttpClient2.layer), Layer2.provide(ConfigProvider.layerAdd(defaults)));
+// src/rounds.ts
+import * as Effect2 from "effect/Effect";
+import * as Metric from "effect/Metric";
+import * as Prompt from "effect/unstable/ai/Prompt";
+var isToolRefusal = (error) => error.reason._tag === "ToolNotFoundError" || error.reason._tag === "InvalidOutputError" && error.module === "LanguageModel";
+var roundsTotal = Metric.counter("seat_rounds_total", {
+  description: "Model turns taken by runRounds that returned; a refused forced final turn is not counted."
+});
+var roundsCapped = Metric.counter("seat_rounds_capped_total", {
+  description: "runRounds runs that hit maxRounds and were given a forced final turn."
+});
+var roundsUnanswered = Metric.counter("seat_rounds_unanswered_total", {
+  description: "runRounds runs whose forced final turn came back as a tool call, not an answer."
+});
+function runRounds(options) {
+  const { chat, toolkit, maxRounds, onRound } = options;
+  return Effect2.gen(function* () {
+    if (!Number.isInteger(maxRounds) || maxRounds < 1) {
+      return yield* Effect2.die(new RangeError(`runRounds: maxRounds must be a positive integer, got ${String(maxRounds)}`));
+    }
+    const finish = (round2, forced2) => Effect2.fnUntraced(function* (response2) {
+      yield* Metric.update(roundsTotal, 1);
+      yield* Effect2.annotateCurrentSpan({ "seat.tool_calls": response2.toolCalls.length });
+      if (onRound !== undefined)
+        yield* onRound({ round: round2, forced: forced2, response: response2 });
+      return response2;
+    });
+    const span = (round2, forced2) => Effect2.withSpan("seat.round", {
+      attributes: { "seat.round": round2, "seat.round.forced": forced2 }
+    });
+    const turn = (round2) => chat.generateText({ prompt: Prompt.empty, toolkit }).pipe(Effect2.flatMap(finish(round2, false)), span(round2, false));
+    let round = 1;
+    let response = yield* turn(round);
+    while (response.toolCalls.length > 0 && round < maxRounds) {
+      round += 1;
+      response = yield* turn(round);
+    }
+    if (response.toolCalls.length === 0) {
+      return { response, rounds: round, capped: false, unanswered: false };
+    }
+    yield* Metric.update(roundsCapped, 1);
+    yield* Effect2.logWarning("seat round cap reached; forcing a final turn without tools", {
+      maxRounds
+    });
+    const forcedRound = maxRounds + 1;
+    const refused = () => Effect2.as(Effect2.all([
+      Metric.update(roundsUnanswered, 1),
+      Effect2.logWarning("seat forced final turn refused: the model still asked for a tool", {
+        maxRounds
+      })
+    ]), undefined);
+    const forced = yield* chat.generateText({ prompt: Prompt.empty, toolChoice: "none" }).pipe(Effect2.flatMap(finish(forcedRound, true)), span(forcedRound, true), Effect2.catchTag("AiError", (error) => isToolRefusal(error) ? refused() : Effect2.fail(error)));
+    return forced === undefined ? { response, rounds: maxRounds, capped: true, unanswered: true } : { response: forced, rounds: forcedRound, capped: true, unanswered: false };
+  });
+}
+// src/mcp-toolkit.ts
+import * as Effect6 from "effect/Effect";
+
+// src/mcp-connect.ts
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { ErrorCode, McpError } from "@modelcontextprotocol/sdk/types.js";
+import * as Effect3 from "effect/Effect";
+import * as Redacted2 from "effect/Redacted";
+
+// src/mcp-error.ts
+function serverLabel(url) {
+  return `${url.origin}${url.pathname}`;
+}
+var MIN_SECRET_LENGTH = 6;
+function queryValues(url) {
+  const raw = url.search.slice(1).split("&").map((pair) => pair.slice(pair.indexOf("=") + 1));
+  return [...raw, ...url.searchParams.values()];
+}
+function headerParts(value) {
+  const token = value.trim().split(/\s+/).at(-1) ?? "";
+  return [value, token];
+}
+function redactor(url, headerValues = []) {
+  const label = serverLabel(url);
+  const whole = [
+    url.search.length > 1 ? url.search : "",
+    url.hash.length > 1 ? url.hash : "",
+    url.password
+  ];
+  const parts = [...queryValues(url), ...headerValues.flatMap(headerParts)];
+  const secrets = [
+    ...whole,
+    ...[...new Set(parts)].filter((part) => part.length >= MIN_SECRET_LENGTH).sort((a, b) => b.length - a.length)
+  ].filter((secret) => secret !== "");
+  return (text) => {
+    let out = text.split(url.href).join(label);
+    for (const secret of secrets)
+      out = out.split(secret).join("[redacted]");
+    return out;
+  };
+}
+var MAX_CAUSE_DEPTH = 5;
+function scrubCause(cause, redact, depth = 0) {
+  if (!(cause instanceof Error))
+    return redact(String(cause));
+  const inner = depth < MAX_CAUSE_DEPTH && cause.cause !== undefined;
+  const copy = new Error(redact(cause.message), inner ? { cause: scrubCause(cause.cause, redact, depth + 1) } : undefined);
+  copy.name = redact(cause.name);
+  if (typeof cause.stack === "string")
+    copy.stack = redact(cause.stack);
+  const code = cause.code;
+  if (typeof code === "string")
+    Object.assign(copy, { code: redact(code) });
+  else if (typeof code === "number")
+    Object.assign(copy, { code });
+  return copy;
+}
+function describeCause(cause) {
+  return cause instanceof Error ? cause.message : String(cause);
+}
+
+class McpToolkitError extends Error {
+  _tag = "McpToolkitError";
+  operation;
+  server;
+  constructor(fields) {
+    const redact = fields.redact ?? ((text) => text);
+    super(`MCP ${fields.operation} against ${fields.server} failed: ${redact(describeCause(fields.cause))}`, { cause: scrubCause(fields.cause, redact) });
+    this.name = "McpToolkitError";
+    this.operation = fields.operation;
+    this.server = fields.server;
+  }
+}
+
+// src/version.ts
+var VERSION = "0.1.0";
+
+// src/mcp-connect.ts
+var DEFAULT_CONNECT_TIMEOUT_MS = 15000;
+var MAX_TIMEOUT_MS = 2 ** 31 - 1;
+var validateTimeout = (timeout) => Number.isFinite(timeout) && timeout > 0 && timeout <= MAX_TIMEOUT_MS ? Effect3.succeed(timeout) : Effect3.die(new RangeError(`connectTimeoutMs must be a finite number of milliseconds above 0 and at most ${String(MAX_TIMEOUT_MS)}, got ${String(timeout)}`));
+var plainHeaders = (headers) => Object.fromEntries(Object.entries(headers ?? {}).map(([name, value2]) => [
+  name,
+  Redacted2.isRedacted(value2) ? Redacted2.value(value2) : value2
+]));
+function headerValues(headers) {
+  return Object.values(plainHeaders(headers));
+}
+async function handshake(client, url, headers, timeout, signal) {
+  const transport = new StreamableHTTPClientTransport(url, {
+    requestInit: { headers: plainHeaders(headers) }
+  });
+  const budget = new AbortController;
+  const stop = AbortSignal.any([signal, budget.signal]);
+  const timer = setTimeout(() => budget.abort(), timeout);
+  const close = () => void client.close().catch(() => {
+    return;
+  });
+  stop.addEventListener("abort", close, { once: true });
+  try {
+    await client.connect(transport, { signal: stop, timeout });
+  } catch (error) {
+    await client.close().catch(() => {
+      return;
+    });
+    const spent = budget.signal.aborted;
+    const sdkTimeout = error instanceof McpError && error.code === ErrorCode.RequestTimeout;
+    throw (spent || sdkTimeout) && !signal.aborted ? new Error(`the MCP handshake did not finish within ${String(timeout)} ms`) : error;
+  } finally {
+    clearTimeout(timer);
+    stop.removeEventListener("abort", close);
+  }
+}
+var connectAndBuild = (url, headers, server, timeout, redact, build) => Effect3.uninterruptibleMask((restore) => Effect3.gen(function* () {
+  const client = new Client({ name: "@homeflare/seat-runtime", version: VERSION });
+  const close = Effect3.ignore(Effect3.tryPromise(() => client.close()));
+  yield* restore(Effect3.tryPromise({
+    try: (signal) => handshake(client, url, headers, timeout, signal),
+    catch: (cause) => new McpToolkitError({ operation: "connect", server, cause, redact })
+  }).pipe(Effect3.withSpan("seat.mcp.connect", { attributes: { "server.address": server } }))).pipe(Effect3.onError(() => close));
+  const built = yield* restore(build(client)).pipe(Effect3.onError(() => close));
+  yield* Effect3.addFinalizer(() => close);
+  return built;
+}));
+
+// src/mcp-pages.ts
+import * as Effect4 from "effect/Effect";
+var MAX_PAGES = 100;
+function collect(operation, server, page, redact) {
+  return Effect4.tryPromise({
+    try: async (signal) => {
+      const items = [];
+      let cursor;
+      for (let pages = 0;pages < MAX_PAGES; pages += 1) {
+        const next = await page(cursor, signal);
+        items.push(...next.items);
+        if (next.next === undefined)
+          return items;
+        cursor = next.next;
+      }
+      throw new Error(`the server returned more than ${String(MAX_PAGES)} pages`);
+    },
+    catch: (cause) => new McpToolkitError({ operation, server, cause, redact })
+  });
+}
+
+// src/mcp-toolset.ts
+import * as Effect5 from "effect/Effect";
+import * as Toolkit from "effect/unstable/ai/Toolkit";
+
+// src/mcp-render.ts
+var EMPTY_RESULT = "(no content)";
+var isBlock = (value2) => typeof value2 === "object" && value2 !== null;
+var str = (value2) => typeof value2 === "string" ? value2 : undefined;
+function renderBlock(block) {
+  const type = str(block["type"]) ?? "unknown";
+  switch (type) {
+    case "text":
+      return str(block["text"]) ?? "";
+    case "image":
+    case "audio":
+      return `[${type}: ${str(block["mimeType"]) ?? "unknown type"}, not shown]`;
+    case "resource_link":
+      return `[resource link: ${str(block["uri"]) ?? "no uri"}]`;
+    case "resource": {
+      const resource = isBlock(block["resource"]) ? block["resource"] : {};
+      return str(resource["text"]) ?? `[resource: ${str(resource["uri"]) ?? "no uri"}, not shown]`;
+    }
+    default:
+      return `[unsupported content block: ${type}]`;
+  }
+}
+function renderContent(content) {
+  if (!Array.isArray(content)) {
+    return content === undefined ? EMPTY_RESULT : JSON.stringify(content);
+  }
+  const lines = content.map((block) => isBlock(block) ? renderBlock(block) : JSON.stringify(block));
+  return lines.length === 0 ? EMPTY_RESULT : lines.join(`
+`);
+}
+function renderResult(result) {
+  const content = "content" in result ? result["content"] : result["toolResult"];
+  if (Array.isArray(content) && content.length === 0 && result["structuredContent"] !== undefined) {
+    return JSON.stringify(result["structuredContent"]);
+  }
+  return renderContent(content);
+}
+
+// src/mcp-tool.ts
+import * as Schema2 from "effect/Schema";
+import * as SchemaGetter from "effect/SchemaGetter";
+import * as Tool from "effect/unstable/ai/Tool";
+function declaredParameters(inputSchema) {
+  const properties = inputSchema["properties"];
+  const names = typeof properties === "object" && properties !== null ? Object.keys(properties) : [];
+  if (names.length === 0)
+    return Tool.EmptyParams;
+  const required = new Set(Array.isArray(inputSchema["required"]) ? inputSchema["required"] : []);
+  const declared = Schema2.Struct(Object.fromEntries(names.map((name) => [
+    name,
+    required.has(name) ? Schema2.Unknown : Schema2.optional(Schema2.Unknown)
+  ])));
+  return declared.pipe(Schema2.decodeTo(Schema2.Unknown, {
+    decode: SchemaGetter.passthrough(),
+    encode: SchemaGetter.forbiddenEncoding
+  }));
+}
+function mcpTool(spec) {
+  const dynamic2 = Tool.dynamic(spec.name, {
+    description: spec.description,
+    parameters: spec.inputSchema,
+    success: Schema2.String,
+    failure: Schema2.String,
+    failureMode: "return"
+  });
+  return Object.assign(Object.create(Object.getPrototypeOf(dynamic2)), dynamic2, {
+    parametersSchema: declaredParameters(spec.inputSchema)
+  });
+}
+
+// src/mcp-toolset.ts
+var isRecord = (value2) => typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
+var call = (client, server, redact, name) => (params) => Effect5.gen(function* () {
+  if (!isRecord(params)) {
+    return yield* Effect5.fail(`${name}: the arguments must be a JSON object`);
+  }
+  const result = yield* Effect5.tryPromise({
+    try: (signal) => client.callTool({ name, arguments: params }, undefined, { signal }),
+    catch: (cause) => `MCP call to ${name} failed: ${redact(describeCause(cause))}`
+  });
+  const text = renderResult(result);
+  return result.isError === true ? yield* Effect5.fail(redact(text)) : text;
+}).pipe(Effect5.withSpan("seat.mcp.call_tool", {
+  attributes: { "mcp.tool": name, "server.address": server }
+}));
+var toolset = (client, server, timeout, redact) => Effect5.gen(function* () {
+  const listed = client.getServerCapabilities()?.tools === undefined ? [] : yield* collect("listTools", server, async (cursor, signal) => {
+    const page = await client.listTools(cursor === undefined ? undefined : { cursor }, {
+      signal,
+      timeout
+    });
+    return { items: page.tools, next: page.nextCursor };
+  }, redact);
+  const tools = listed.map((tool) => mcpTool({ name: tool.name, description: tool.description, inputSchema: tool.inputSchema }));
+  const definition = Toolkit.make(...tools);
+  const handlers = Object.fromEntries(tools.map((tool) => [tool.name, call(client, server, redact, tool.name)]));
+  const context = yield* definition.toHandlers(handlers);
+  return yield* definition.pipe(Effect5.provideContext(context));
+});
+
+// src/mcp-toolkit.ts
+function resourcesOf(client, server, redact) {
+  const listResources = Effect6.suspend(() => client.getServerCapabilities()?.resources === undefined ? Effect6.succeed([]) : collect("listResources", server, async (cursor, signal) => {
+    const page = await client.listResources(cursor === undefined ? undefined : { cursor }, {
+      signal
+    });
+    return {
+      items: page.resources.map((resource) => ({
+        uri: resource.uri,
+        name: resource.name,
+        description: resource.description,
+        mimeType: resource.mimeType
+      })),
+      next: page.nextCursor
+    };
+  }, redact)).pipe(Effect6.withSpan("seat.mcp.list_resources", { attributes: { "server.address": server } }));
+  const readResource = (uri) => Effect6.tryPromise({
+    try: async (signal) => {
+      const read = await client.readResource({ uri }, { signal });
+      return read.contents.map((entry) => ({
+        uri: entry.uri,
+        mimeType: entry.mimeType,
+        text: "text" in entry ? entry.text : undefined,
+        blob: "blob" in entry ? entry.blob : undefined
+      }));
+    },
+    catch: (cause) => new McpToolkitError({ operation: "readResource", server, cause, redact })
+  }).pipe(Effect6.withSpan("seat.mcp.read_resource", {
+    attributes: { "mcp.resource": uri, "server.address": server }
+  }));
+  return { listResources, readResource };
+}
+function mcpToolkit(url, headers, options) {
+  return Effect6.gen(function* () {
+    const timeout = yield* validateTimeout(options?.connectTimeoutMs ?? DEFAULT_CONNECT_TIMEOUT_MS);
+    const target = yield* Effect6.try({
+      try: () => new URL(url),
+      catch: () => new McpToolkitError({
+        operation: "connect",
+        server: "(unparseable URL)",
+        cause: "the URL did not parse"
+      })
+    });
+    const server = serverLabel(target);
+    const redact = redactor(target, headerValues(headers));
+    return yield* connectAndBuild(target, headers, server, timeout, redact, (client) => Effect6.gen(function* () {
+      const toolkit = yield* toolset(client, server, timeout, redact);
+      return { toolkit, ...resourcesOf(client, server, redact) };
+    }));
+  });
+}
+export {
+  McpToolkitError,
+  exports_seat_model as SeatModel,
+  exports_seat_obs as SeatObs,
+  VERSION,
+  mcpToolkit,
+  runRounds
+};
+
+//# debugId=61F68CACADDB04EE64756E2164756E21
+//# sourceMappingURL=index.js.map