@hraness/sys1 0.17.0

package/dist/config.d.ts

@@ -0,0 +1,126 @@
+import { z } from "zod";
+export declare const ROUTING_POLICIES: readonly ["auto", "prefer-local", "prefer-hosted", "local-only", "hosted-only"];
+export declare const routingPolicySchema: z.ZodEnum<{
+    auto: "auto";
+    "prefer-local": "prefer-local";
+    "prefer-hosted": "prefer-hosted";
+    "local-only": "local-only";
+    "hosted-only": "hosted-only";
+}>;
+export type RoutingPolicy = z.infer<typeof routingPolicySchema>;
+export declare function isLoopbackHost(host: string): boolean;
+export declare const loopbackHostSchema: z.ZodString;
+export declare const localBackendSchema: z.ZodObject<{
+    name: z.ZodString;
+    base_url: z.ZodURL;
+    model: z.ZodString;
+    adapter: z.ZodOptional<z.ZodEnum<{
+        systemone: "systemone";
+        kev: "kev";
+    }>>;
+    size_b: z.ZodOptional<z.ZodNumber>;
+    cost_rank: z.ZodOptional<z.ZodNumber>;
+    capabilities: z.ZodOptional<z.ZodObject<{
+        max_options: z.ZodOptional<z.ZodNumber>;
+        max_questions: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const configSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    gateway: z.ZodPrefault<z.ZodObject<{
+        host: z.ZodDefault<z.ZodString>;
+        port: z.ZodDefault<z.ZodNumber>;
+        request_timeout_ms: z.ZodDefault<z.ZodNumber>;
+        probe_timeout_ms: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    routing: z.ZodPrefault<z.ZodObject<{
+        policy: z.ZodDefault<z.ZodEnum<{
+            auto: "auto";
+            "prefer-local": "prefer-local";
+            "prefer-hosted": "prefer-hosted";
+            "local-only": "local-only";
+            "hosted-only": "hosted-only";
+        }>>;
+    }, z.core.$strip>>;
+    hosted: z.ZodPrefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        base_url: z.ZodDefault<z.ZodURL>;
+        model: z.ZodDefault<z.ZodString>;
+        api_key_env: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>>;
+    local: z.ZodPrefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        model: z.ZodDefault<z.ZodString>;
+        context_tokens: z.ZodDefault<z.ZodNumber>;
+        eval_timeout_ms: z.ZodDefault<z.ZodNumber>;
+        max_loaded_models: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    backends: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        base_url: z.ZodURL;
+        model: z.ZodString;
+        adapter: z.ZodOptional<z.ZodEnum<{
+            systemone: "systemone";
+            kev: "kev";
+        }>>;
+        size_b: z.ZodOptional<z.ZodNumber>;
+        cost_rank: z.ZodOptional<z.ZodNumber>;
+        capabilities: z.ZodOptional<z.ZodObject<{
+            max_options: z.ZodOptional<z.ZodNumber>;
+            max_questions: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        enabled: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type LocalBackendConfig = z.infer<typeof localBackendSchema>;
+export type Sys1Config = z.infer<typeof configSchema>;
+export declare const DEFAULT_CONFIG: Sys1Config;
+export declare function sys1Home(env?: NodeJS.ProcessEnv): string;
+export declare function configPath(home: string): string;
+export declare function pidPath(home: string): string;
+export declare function logPath(home: string): string;
+export type ConfigLoadResult = {
+    ok: true;
+    config: Sys1Config;
+    path: string;
+    existed: boolean;
+} | {
+    ok: false;
+    path: string;
+    message: string;
+};
+export declare function loadConfig(home: string): ConfigLoadResult;
+export declare function saveConfig(home: string, config: Sys1Config): string;
+export declare const SETTABLE_KEYS: {
+    readonly "routing.policy": z.ZodEnum<{
+        auto: "auto";
+        "prefer-local": "prefer-local";
+        "prefer-hosted": "prefer-hosted";
+        "local-only": "local-only";
+        "hosted-only": "hosted-only";
+    }>;
+    readonly "gateway.host": z.ZodString;
+    readonly "gateway.port": z.ZodCoercedNumber<unknown>;
+    readonly "gateway.request_timeout_ms": z.ZodCoercedNumber<unknown>;
+    readonly "gateway.probe_timeout_ms": z.ZodCoercedNumber<unknown>;
+    readonly "hosted.base_url": z.ZodURL;
+    readonly "hosted.model": z.ZodString;
+    readonly "hosted.api_key_env": z.ZodString;
+    readonly "local.enabled": z.ZodPipe<z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>, z.ZodTransform<boolean, "false" | "true">>;
+    readonly "local.model": z.ZodString;
+    readonly "local.context_tokens": z.ZodCoercedNumber<unknown>;
+    readonly "local.eval_timeout_ms": z.ZodCoercedNumber<unknown>;
+    readonly "local.max_loaded_models": z.ZodCoercedNumber<unknown>;
+};
+export type SettableKey = keyof typeof SETTABLE_KEYS;
+export declare function setConfigValue(config: Sys1Config, key: SettableKey, rawValue: string): {
+    ok: true;
+    config: Sys1Config;
+} | {
+    ok: false;
+    message: string;
+};

package/dist/daemon.d.ts

@@ -0,0 +1,57 @@
+import { z } from "zod";
+import { type Sys1Config } from "./config.ts";
+declare const pidFileSchema: z.ZodObject<{
+    pid: z.ZodNumber;
+    port: z.ZodNumber;
+    host: z.ZodString;
+    instance: z.ZodString;
+    started_at: z.ZodString;
+}, z.core.$strip>;
+export type PidFile = z.infer<typeof pidFileSchema>;
+export declare function readPidFile(home: string): PidFile | null;
+export declare function processAlive(pid: number): boolean;
+export declare function gatewayUrl(host: string, port: number): string;
+export declare function healthz(host: string, port: number, timeoutMs?: number, fetchFn?: typeof fetch): Promise<boolean>;
+export type DaemonState = {
+    state: "running";
+    pid: number;
+    port: number;
+    host: string;
+    started_at: string;
+} | {
+    state: "stale_pidfile";
+    pid: number;
+} | {
+    state: "foreign_listener";
+    port: number;
+} | {
+    state: "stopped";
+};
+export declare function daemonStatus(home: string, config: Sys1Config, fetchFn?: typeof fetch): Promise<DaemonState>;
+export interface UpResult {
+    ok: boolean;
+    message: string;
+    pid?: number;
+    url?: string;
+}
+/**
+ * Spawn a detached `sys1 serve` child and wait for its health check. The
+ * child writes the pid file itself after binding; this function only polls.
+ */
+export declare function daemonUp(options: {
+    home: string;
+    config: Sys1Config;
+    cliEntry: string;
+    env: NodeJS.ProcessEnv;
+    fetchFn?: typeof fetch;
+    waitMs?: number;
+}): Promise<UpResult>;
+export interface DownResult {
+    ok: boolean;
+    message: string;
+}
+export declare function daemonDown(home: string, config: Sys1Config, fetchFn?: typeof fetch): Promise<DownResult>;
+/** Called by the detached `serve --daemon-child` process after binding. */
+export declare function writePidFile(home: string, pid: number, host: string, port: number, instance: string): void;
+export declare function clearPidFile(home: string, pid: number): void;
+export {};

package/dist/defaults.d.ts

@@ -0,0 +1,20 @@
+export declare const LOCAL_MODEL_TIERS: readonly ["compact", "quality"];
+export type LocalModelTier = (typeof LOCAL_MODEL_TIERS)[number];
+export declare const DEFAULT_LOCAL_MODELS: Record<LocalModelTier, string>;
+export interface PlatformRecommendation {
+    platform: string;
+    arch: string;
+    target: string;
+    supported: boolean;
+    acceleration: string;
+    tier: LocalModelTier;
+    model: string | null;
+    /** Model decision quality remains experimental, independent of runtime support. */
+    experimental?: boolean;
+    reason: string;
+}
+export declare function platformRecommendation(options?: {
+    platform?: string;
+    arch?: string;
+    tier?: LocalModelTier;
+}): PlatformRecommendation;

package/dist/doctor.d.ts

@@ -0,0 +1,29 @@
+import { type Sys1Config } from "./config.ts";
+import { type DaemonState } from "./daemon.ts";
+import { type NativeRuntimeProbe } from "./local/engine.ts";
+import type { JsonValue } from "./protocol.ts";
+export type DoctorStatus = "pass" | "warn" | "fail";
+export interface DoctorCheck {
+    id: string;
+    status: DoctorStatus;
+    summary: string;
+    detail?: JsonValue;
+}
+export interface DoctorReport {
+    ok: boolean;
+    version: 1;
+    checks: DoctorCheck[];
+    counts: {
+        pass: number;
+        warn: number;
+        fail: number;
+    };
+}
+export interface DoctorOptions {
+    home: string;
+    env?: NodeJS.ProcessEnv;
+    runtimeVersion?: string;
+    nativeProbe?: () => Promise<NativeRuntimeProbe>;
+    daemonProbe?: (home: string, config: Sys1Config) => Promise<DaemonState>;
+}
+export declare function runDoctor(options: DoctorOptions): Promise<DoctorReport>;

package/dist/engine-worker.js

@@ -0,0 +1,256 @@
+// src/local/engine-worker.ts
+import { z } from "zod";
+
+// src/local/engine-types.ts
+class EngineUnavailableError extends Error {
+  detail;
+  constructor(message, detail) {
+    super(message);
+    this.name = "EngineUnavailableError";
+    this.detail = detail;
+  }
+}
+var ENGINE_IPC_LIMITS = {
+  requestBytes: 131072,
+  responseBytes: 16 * 1048576,
+  maxEntries: 300000,
+  maxTokenBytes: 4096,
+  maxPromptBytes: 65536
+};
+
+// src/local/input.ts
+class LocalInputError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "LocalInputError";
+  }
+}
+
+// src/local/engine-core.ts
+async function loadNodeLlamaCpp() {
+  const specifier = "node-llama-cpp";
+  return await import(specifier);
+}
+async function runNativeProbe(loadModule = loadNodeLlamaCpp) {
+  let llama = null;
+  try {
+    const mod = await loadModule();
+    const supported = await mod.getLlamaGpuTypes("supported");
+    llama = await mod.getLlama({ gpu: "auto", logLevel: "fatal", build: "never", skipDownload: true });
+    return {
+      ok: true,
+      backend: llama.gpu === false || llama.gpu === undefined ? "cpu" : llama.gpu,
+      gpu_offloading: llama.supportsGpuOffloading ?? false,
+      supported_backends: supported.map((backend) => backend === false ? "cpu" : backend)
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      message: error instanceof Error ? error.message : "native runtime unavailable"
+    };
+  } finally {
+    if (llama !== null)
+      await llama.dispose().catch(() => {});
+  }
+}
+
+class NativeLlamaEngine {
+  loadModule;
+  modelId;
+  options;
+  llama = null;
+  model = null;
+  context = null;
+  chatWrapper = null;
+  disposed = false;
+  constructor(options, loadModule = loadNodeLlamaCpp) {
+    this.loadModule = loadModule;
+    this.options = options;
+    this.modelId = options.modelId;
+  }
+  async ensureLoaded() {
+    if (this.context !== null)
+      return;
+    let mod;
+    try {
+      mod = await this.loadModule();
+    } catch {
+      throw new EngineUnavailableError("node-llama-cpp is not installed", "reinstall @hraness/sys1 or run `bun add node-llama-cpp`");
+    }
+    try {
+      this.llama = await mod.getLlama({ gpu: "auto", logLevel: "fatal", build: "never", skipDownload: true });
+    } catch (error) {
+      if (mod.NoBinaryFoundError !== undefined && error instanceof mod.NoBinaryFoundError) {
+        throw new EngineUnavailableError("llama.cpp binaries are not installed", "run `bun pm trust node-llama-cpp && bun install` or `sys1 doctor` for setup help");
+      }
+      throw error;
+    }
+    try {
+      this.model = await this.llama.loadModel({ modelPath: this.options.modelPath });
+      this.chatWrapper = mod.resolveChatWrapper(this.model, {
+        customWrapperSettings: { qwen: { thoughts: "discourage" } }
+      });
+      this.context = await this.model.createContext({ contextSize: this.options.contextSize });
+    } catch (error) {
+      if (this.context !== null)
+        await this.context.dispose().catch(() => {});
+      if (this.model !== null)
+        await this.model.dispose().catch(() => {});
+      if (this.llama !== null)
+        await this.llama.dispose().catch(() => {});
+      this.context = null;
+      this.model = null;
+      this.chatWrapper = null;
+      this.llama = null;
+      throw new EngineUnavailableError("local model failed to load", error instanceof Error ? error.message : this.modelId);
+    }
+  }
+  async firstTokenDistribution(prompt) {
+    if (this.disposed)
+      throw new EngineUnavailableError("engine is disposed", this.modelId);
+    await this.ensureLoaded();
+    const model = this.model;
+    const context = this.context;
+    const chatWrapper = this.chatWrapper;
+    if (model === null || context === null || chatWrapper === null) {
+      throw new EngineUnavailableError("engine failed to initialize", this.modelId);
+    }
+    const rendered = chatWrapper.generateContextState({
+      chatHistory: [
+        {
+          type: "system",
+          text: "You are a precise decision engine. Follow the requested answer format exactly and do not explain."
+        },
+        { type: "user", text: prompt },
+        { type: "model", response: [] }
+      ]
+    });
+    const tokens = rendered.contextText.tokenize(model.tokenizer);
+    if (tokens.length >= context.contextSize) {
+      throw new LocalInputError("prompt tokens exceed the model context capacity");
+    }
+    const sequence = context.getSequence();
+    try {
+      const generator = sequence.evaluateWithMetadata(tokens, { probabilities: true }, { temperature: 0, yieldEogToken: true });
+      const first = await generator.next();
+      await generator.return(undefined).catch(() => {});
+      const probs = first.done ? undefined : first.value.probabilities;
+      if (probs === undefined) {
+        throw new EngineUnavailableError("model produced no distribution", this.modelId);
+      }
+      const entries = [];
+      for (const [token, p] of probs) {
+        if (typeof p !== "number" || !(p > 0))
+          continue;
+        entries.push([model.detokenize([token]), p]);
+      }
+      return { entries, inputTokens: tokens.length };
+    } finally {
+      await sequence.dispose().catch(() => {});
+    }
+  }
+  async dispose() {
+    this.disposed = true;
+    if (this.context !== null)
+      await this.context.dispose().catch(() => {});
+    if (this.model !== null)
+      await this.model.dispose().catch(() => {});
+    if (this.llama !== null)
+      await this.llama.dispose().catch(() => {});
+    this.context = null;
+    this.model = null;
+    this.chatWrapper = null;
+    this.llama = null;
+  }
+}
+
+// src/local/engine-ipc.ts
+import { write } from "node:fs";
+import { setTimeout as delay } from "node:timers/promises";
+async function writeEngineMessage(value) {
+  const wire = Buffer.from(`${JSON.stringify(value)}
+`);
+  if (wire.length > ENGINE_IPC_LIMITS.responseBytes)
+    throw new Error("worker_response_limit");
+  let offset = 0;
+  while (offset < wire.length) {
+    const written = await new Promise((resolve, reject) => {
+      write(1, wire, offset, wire.length - offset, null, (error, count) => {
+        if (error !== null) {
+          if (error.code === "EAGAIN" || error.code === "EWOULDBLOCK")
+            resolve(0);
+          else
+            reject(error);
+        } else
+          resolve(count);
+      });
+    });
+    if (written === 0)
+      await delay(1);
+    offset += written;
+  }
+}
+
+// src/local/engine-worker.ts
+var requestSchema = z.discriminatedUnion("op", [
+  z.object({ id: z.number().int().positive(), op: z.literal("probe") }).strict(),
+  z.object({
+    id: z.number().int().positive(),
+    op: z.literal("evaluate"),
+    options: z.object({
+      modelPath: z.string().min(1).max(4096),
+      modelId: z.string().min(1).max(128),
+      contextSize: z.number().int().min(256).max(65536),
+      evalTimeoutMs: z.number().int().min(1).max(300000)
+    }).strict(),
+    prompt: z.string().refine((text) => Buffer.byteLength(text) <= ENGINE_IPC_LIMITS.maxPromptBytes)
+  }).strict()
+]);
+var engine;
+var identity;
+var busy = false;
+var chunks = [];
+var bytes = 0;
+async function handle(wire) {
+  const parsed = requestSchema.safeParse(JSON.parse(wire));
+  if (!parsed.success)
+    process.exit(1);
+  const request = parsed.data;
+  try {
+    if (request.op === "probe") {
+      const result = await runNativeProbe();
+      await writeEngineMessage({ id: request.id, kind: "probe", value: result.ok ? result : { ok: false, message: "native runtime unavailable" } });
+    } else {
+      const nextIdentity = JSON.stringify(request.options);
+      if (identity !== undefined && nextIdentity !== identity)
+        process.exit(1);
+      identity = nextIdentity;
+      engine ??= new NativeLlamaEngine(request.options);
+      await writeEngineMessage({ id: request.id, kind: "distribution", value: await engine.firstTokenDistribution(request.prompt) });
+    }
+  } catch (error) {
+    await writeEngineMessage({ id: request.id, kind: error instanceof LocalInputError ? "unsupported" : "error", detail: error instanceof LocalInputError ? "context_limit" : "native_inference_failed" });
+  }
+}
+process.stdin.on("data", (chunk) => {
+  if (busy)
+    process.exit(1);
+  bytes += chunk.byteLength;
+  if (bytes > ENGINE_IPC_LIMITS.requestBytes)
+    process.exit(1);
+  chunks.push(chunk);
+  const newline = chunk.indexOf(10);
+  if (newline < 0)
+    return;
+  if (newline !== chunk.length - 1)
+    process.exit(1);
+  const wire = Buffer.concat(chunks, bytes).toString("utf8");
+  chunks = [];
+  bytes = 0;
+  busy = true;
+  handle(wire).then(() => {
+    busy = false;
+  }, () => process.exit(1));
+});
+process.stdin.on("end", () => process.exit(0));
+process.stdin.on("error", () => process.exit(1));

package/dist/gateway.d.ts

@@ -0,0 +1,36 @@
+import { type Sys1Config } from "./config.ts";
+import { LocalRunner } from "./local/runner.ts";
+export declare const SYS1_VERSION = "0.17.0";
+export interface GatewayDeps {
+    config: Sys1Config;
+    env: NodeJS.ProcessEnv;
+    fetchFn?: typeof fetch;
+    /**
+     * Re-read config per request so `sys1 config set` / `backend add` take
+     * effect on a running daemon. May throw; a thrown read answers 503.
+     */
+    reloadConfig?: () => Sys1Config;
+    /**
+     * State directory. Required for builtin local models; when absent the
+     * gateway only serves URL-registered and hosted backends.
+     */
+    home?: string;
+    /** Injectable local runner (tests substitute a fake engine factory). */
+    localRunner?: LocalRunner;
+    /** Daemon ownership proof. Standalone embedded gateways omit this. */
+    daemon?: {
+        instance: string;
+        onShutdown: () => void | Promise<void>;
+    };
+}
+export declare function createFetchHandler(deps: GatewayDeps): (req: Request) => Promise<Response>;
+export interface RunningGateway {
+    url: string;
+    port: number;
+    stop: () => Promise<void>;
+}
+/** Network admission wrapper, shared by the listener and boundary tests. */
+export declare function createNetworkFetchHandler(deps: GatewayDeps): (req: Request) => Promise<Response>;
+export declare function startGateway(deps: GatewayDeps & {
+    port?: number;
+}): RunningGateway;

package/dist/http.d.ts

@@ -0,0 +1,9 @@
+/** A body exceeded its byte limit before it finished streaming. */
+export declare class HttpBodyLimitError extends Error {
+    readonly maxBytes: number;
+    constructor(maxBytes: number);
+}
+/** Read at most maxBytes, canceling the stream on overflow or caller abort. */
+export declare function readBoundedText(source: {
+    body: ReadableStream<Uint8Array> | null;
+}, maxBytes: number, signal?: AbortSignal): Promise<string>;

package/dist/index.d.ts

@@ -0,0 +1,32 @@
+export { PROTOCOL_LIMITS, answerSchema, choiceAnswerSchema, choiceQuestionSchema, entrySchema, errorBody, noulAnswerSchema, noulQuestionSchema, questionSchema, scoreAnswerSchema, scoreQuestionSchema, serializedBytes, systemOneRequestSchema, systemOneResponseSchema, } from "./protocol.ts";
+export type { Answer, ChoiceAnswer, ChoiceQuestion, EntryType, GatewayError, JsonValue, NoulAnswer, NoulQuestion, Question, ScoreAnswer, ScoreQuestion, SystemOneRequest, SystemOneResponse, } from "./protocol.ts";
+export { DEFAULT_CONFIG, ROUTING_POLICIES, SETTABLE_KEYS, configSchema, isLoopbackHost, loadConfig, localBackendSchema, loopbackHostSchema, routingPolicySchema, saveConfig, setConfigValue, sys1Home, } from "./config.ts";
+export type { LocalBackendConfig, RoutingPolicy, SettableKey, Sys1Config, } from "./config.ts";
+export { chooseBackend, requestNeeds } from "./router.ts";
+export type { BackendCandidate, BackendCapabilities, BackendKind, RequestNeeds, RouteChoice, } from "./router.ts";
+export { HOSTED_BACKEND_NAME, extractBackendCapabilities, extractModelIds, forwardToBackend, probeAll, probeBackend, runtimeBackends, } from "./backends.ts";
+export type { ForwardResult, ProbeResult, RuntimeBackend } from "./backends.ts";
+export { DEFAULT_LOCAL_MODELS, LOCAL_MODEL_TIERS, platformRecommendation, } from "./defaults.ts";
+export type { LocalModelTier, PlatformRecommendation } from "./defaults.ts";
+export { qualifyBackend } from "./qualification.ts";
+export type { BackendQualificationCheck, BackendQualificationOptions, BackendQualificationReport, BackendQualificationStatus, } from "./qualification.ts";
+export { SYS1_VERSION, createFetchHandler, startGateway } from "./gateway.ts";
+export type { GatewayDeps, RunningGateway } from "./gateway.ts";
+export { runDoctor } from "./doctor.ts";
+export type { DoctorCheck, DoctorOptions, DoctorReport, DoctorStatus, } from "./doctor.ts";
+export { clearPidFile, daemonDown, daemonStatus, daemonUp, healthz, processAlive, readPidFile, writePidFile, } from "./daemon.ts";
+export type { DaemonState, DownResult, PidFile, UpResult } from "./daemon.ts";
+export { DECIDE_LIMITS, DECISION_LABELS, aggregateMass, answerLabels, confidenceOf, decisionPrompt, outcomeFromMass, toLocalAnswer, toLocalResponse, } from "./local/decide.ts";
+export type { LabelMass, LocalAnswer, LocalResponse, QuestionOutcome, } from "./local/decide.ts";
+export { EngineUnavailableError, LlamaEngine, probeNativeRuntime, } from "./local/engine.ts";
+export type { DecisionEngine, FirstTokenDistribution, LlamaEngineOptions, NativeRuntimeProbe, } from "./local/engine.ts";
+export { BUILTIN_PREFIX, LocalRunner, builtinCandidates, builtinName, defaultEngineFactory, } from "./local/runner.ts";
+export type { BuiltinCandidate, DecideResult, EngineFactory, LocalAdapter, LocalQuestionDiagnostic, RunnerOptions, } from "./local/runner.ts";
+export { MODEL_KINDS, MODEL_LIMITS, MODEL_REGISTRY, ModelStoreError, findInstalled, findRegistry, inspectGgufFile, installedModels, loadManifest, loadManifestChecked, manifestPath, modelFilePath, modelsDir, pullModel, removeModel, resolvePullTarget, saveManifest, storeBytes, verifyModel, } from "./local/store.ts";
+export type { GgufInspection, InstalledModel, Manifest, ManifestLoadResult, ModelKind, PullOptions, PullResult, PullTarget, RegistryEntry, VerifyModelResult, } from "./local/store.ts";
+export { createClient, DEFAULT_BASE_URL, Sys1ClientError } from "./client.ts";
+export type { ClientErrorCode, ClientOptions, EvaluationOptions, EvaluationResult, RouteMetadata, Sys1Client, } from "./client.ts";
+export { createRouter } from "./runtime.ts";
+export type { RouterOptions, EmbeddedRouter } from "./runtime.ts";
+export { createProfile, Sys1ProfileError } from "./profile.ts";
+export type { DecisionProfile, ProfileDefinition, ReadonlyProfileDefinition, ProfileErrorCode, } from "./profile.ts";