@skaile/transform-proxy 0.0.0-stage → 0.1.0

package/dist/index.d.mts

@@ -0,0 +1,86 @@
+import { _ as TransformModule, a as TransformProxyOptions, c as TransformSpec, d as SessionFactPublisher, f as SessionFacts, g as TransformFactory, h as Transform, i as TransformProxy, l as Logger, m as TextLeafKind, n as SESSION_HEADER, o as UPSTREAM_HEADER, p as TextLeaf, r as TOKEN_HEADER, s as createTransformProxy, t as PIPELINE_HEADER, u as SessionFact, v as TransformSessionContext } from "./server-D5nBnO7T.mjs";
+/** One stage's streamed inbound transformer, as returned by `Transform.inboundStream()`. */
+interface InboundStream {
+  push(chunk: string): string;
+  flush(): string;
+}
+/**
+ * Composes the stages of one pipeline into a single transform.
+ * Outbound runs stage 1 to n, inbound and streamed inbound run stage n to 1.
+ * The empty list is the identity.
+ */
+export declare function composeTransforms(stages: readonly Transform[], log?: Logger): Transform;
+/** Default logger: drops everything. Hosts pass their own `Logger`. */
+export declare const silentLogger: Logger;
+/** One session's facts: the read side for transforms and the per-source publishers for connectors. */
+interface SessionFactStore {
+  readonly facts: SessionFacts;
+  publisher(source: string): SessionFactPublisher;
+}
+export declare function createSessionFacts(): SessionFactStore;
+export declare const CONFIG_FILE_NAME = "transform-proxy.yaml";
+/** The YAML-backed subset of the proxy options. `baseDir` is the config file's directory. */
+interface ProxyConfig {
+  readonly baseDir: string;
+  readonly transforms: Record<string, TransformSpec>;
+  readonly pipelines: Record<string, readonly string[]>;
+  readonly defaultPipeline?: string;
+  readonly allowUpstreams?: readonly string[];
+}
+interface ResolvedProxyConfig {
+  readonly path: string;
+  readonly options: ProxyConfig;
+}
+interface ConfigLookup {
+  /** The `--config` value, relative to `cwd`. When set, it is the only candidate. */
+  readonly explicit?: string;
+  readonly cwd: string;
+  readonly home: string;
+}
+/** The implicit lookup locations, in order: `./.skaile/` then `~/.config/skaile/`. */
+export declare function configCandidates(cwd: string, home: string): readonly string[];
+/**
+ * Finds the config file: the explicit path when given (it must exist), otherwise the first
+ * existing implicit candidate. Returns `undefined` when no implicit candidate exists.
+ */
+export declare function findProxyConfig(lookup: ConfigLookup): string | undefined;
+/** Finds and loads the config. Throws, naming the searched paths, when none is found. */
+export declare function resolveProxyConfig(lookup: ConfigLookup): ResolvedProxyConfig;
+/** Reads and validates a YAML config file. Unknown keys are rejected so that typos fail loudly. */
+export declare function loadProxyConfig(path: string): ProxyConfig;
+/** Validates an already-parsed config object. Exported for hosts that load YAML themselves. */
+export declare function parseProxyConfig(source: unknown, baseDir: string): ProxyConfig;
+interface WireContext {
+  /** The session's composed pipeline. */
+  readonly transform: Transform;
+  /**
+   * Session-scoped cache of signed reasoning: key -> text exactly as the model produced it.
+   * Walkers namespace their keys (`anthropic:<signature>`, `responses:<itemId>`).
+   */
+  readonly signatures: Map<string, string>;
+}
+/** Thrown by `request` for attachments (image, document, file parts); the server answers 400 `unsupported_content`. */
+export declare class UnsupportedContentError extends Error {
+  readonly code = "unsupported_content";
+  constructor(message: string);
+}
+/** A text transformer over raw SSE text; safe at any chunk boundary. */
+interface SseTransformer {
+  push(chunk: string): string;
+  flush(): string;
+}
+/** Pure functions over one wire protocol's parsed JSON. */
+interface WireWalker {
+  /**
+   * Returns the request body with every text leaf passed through `outbound` and the
+   * pipeline `instruction` added to the system prompt. Throws `UnsupportedContentError`
+   * for attachments; `outbound` errors propagate unchanged.
+   */
+  request(body: unknown, ctx: WireContext): Promise<unknown>;
+  /** Restores a non-streamed JSON response. */
+  response(body: unknown, ctx: WireContext): unknown;
+  /** SSE event transformer for a streamed response. */
+  stream(ctx: WireContext): SseTransformer;
+}
+export declare const anthropicWalker: WireWalker;
+export { type ConfigLookup, type InboundStream, type Logger, PIPELINE_HEADER, type ProxyConfig, type ResolvedProxyConfig, SESSION_HEADER, type SessionFact, type SessionFactPublisher, type SessionFactStore, type SessionFacts, type SseTransformer, TOKEN_HEADER, type TextLeaf, type TextLeafKind, type Transform, type TransformFactory, type TransformModule, type TransformProxy, type TransformProxyOptions, type TransformSessionContext, type TransformSpec, UPSTREAM_HEADER, type WireContext, type WireWalker, createTransformProxy };

package/dist/index.mjs

@@ -0,0 +1 @@
+export { t as CONFIG_FILE_NAME, s as PIPELINE_HEADER, c as SESSION_HEADER, l as TOKEN_HEADER, u as UPSTREAM_HEADER, p as UnsupportedContentError, f as anthropicWalker, h as composeTransforms, n as configCandidates, m as createSessionFacts, d as createTransformProxy, r as findProxyConfig, i as loadProxyConfig, a as parseProxyConfig, o as resolveProxyConfig, _ as silentLogger } from "./config-BKD-ILIz.mjs";

package/dist/server-D5nBnO7T.d.mts

@@ -0,0 +1,96 @@
+/** Minimal logger; structurally compatible with the workspaces `Logger`. */
+interface Logger {
+  debug(msg: string, ...args: unknown[]): void;
+  info(msg: string, ...args: unknown[]): void;
+  warn(msg: string, ...args: unknown[]): void;
+  error(msg: string, ...args: unknown[]): void;
+}
+type TextLeafKind = 'system' | 'user' | 'assistant' | 'thinking' | 'toolCall' | 'toolResult';
+interface TextLeaf {
+  readonly kind: TextLeafKind;
+  readonly toolName?: string;
+}
+/** One session's instance of one pipeline stage. */
+interface Transform {
+  /** Prepended to the system prompt; omit when the model needs no instruction. */
+  readonly instruction?: string;
+  /** Host -> model, one text leaf. A throw refuses the request (502 `transform_failed`); nothing is sent. */
+  outbound(text: string, leaf: TextLeaf): Promise<string>;
+  /** Model -> host, one complete text. */
+  inbound(text: string): string;
+  /** Model -> host, one streamed text block. Invariant: push(c1)+...+push(cn)+flush() === inbound(c1+...+cn). */
+  inboundStream(): {
+    push(chunk: string): string;
+    flush(): string;
+  };
+  /** Called once when the proxy drops the session. */
+  dispose?(): void | Promise<void>;
+}
+interface SessionFact {
+  readonly kind: string;
+  readonly value: string;
+  readonly source: string;
+}
+interface SessionFacts {
+  /** Bumped on every publish/clear; readers re-read `list()` only when it changed. */
+  readonly version: number;
+  list(kind?: string): readonly SessionFact[];
+}
+interface SessionFactPublisher {
+  /** Replaces this publisher's facts (source = publisher id). */
+  publish(facts: readonly Omit<SessionFact, 'source'>[]): void;
+  clear(): void;
+}
+interface TransformSessionContext {
+  readonly sessionId: string;
+  readonly facts: SessionFacts;
+  readonly log: Logger;
+}
+type TransformFactory = (ctx: TransformSessionContext) => Promise<Transform>;
+/** Default export of a transform module, e.g. `@skaile/forge-anon/proxy`. */
+interface TransformModule {
+  readonly id: string;
+  /** Once per proxy and config: validate config, build shared heavy state (detectors). Throws on a bad config. */
+  open(config: unknown, ctx: {
+    readonly baseDir: string;
+    readonly log: Logger;
+  }): Promise<TransformFactory>;
+}
+/** A configured transform: a module (object, npm specifier or relative path) and its config. */
+interface TransformSpec {
+  readonly module: string | TransformModule;
+  readonly config?: unknown;
+}
+interface TransformProxyOptions {
+  /** Default 127.0.0.1. A non-loopback host requires `token`. */
+  host?: string;
+  /** Default 0 (ephemeral). */
+  port?: number;
+  /** Required `x-skaile-transform-token` when set. */
+  token?: string;
+  /** Where transform module specifiers and configs resolve. */
+  baseDir: string;
+  transforms: Readonly<Record<string, TransformSpec>>;
+  pipelines: Readonly<Record<string, readonly string[]>>;
+  /** Used when the request names no pipeline. Absent = such requests are refused. */
+  defaultPipeline?: string;
+  /** Origins. Absent = any https origin plus loopback http. */
+  allowUpstreams?: readonly string[];
+  log?: Logger;
+}
+interface TransformProxy {
+  readonly url: string;
+  session(id: string): {
+    readonly facts: SessionFacts;
+    publisher(source: string): SessionFactPublisher;
+  };
+  /** Disposes the session's transform instances and forgets its facts and caches. */
+  dropSession(id: string): Promise<void>;
+  close(): Promise<void>;
+}
+declare const UPSTREAM_HEADER = "x-skaile-transform-upstream";
+declare const SESSION_HEADER = "x-skaile-transform-session";
+declare const PIPELINE_HEADER = "x-skaile-transform-pipeline";
+declare const TOKEN_HEADER = "x-skaile-transform-token";
+declare function createTransformProxy(options: TransformProxyOptions): Promise<TransformProxy>;
+export { TransformModule as _, TransformProxyOptions as a, TransformSpec as c, SessionFactPublisher as d, SessionFacts as f, TransformFactory as g, Transform as h, TransformProxy as i, Logger as l, TextLeafKind as m, SESSION_HEADER as n, UPSTREAM_HEADER as o, TextLeaf as p, TOKEN_HEADER as r, createTransformProxy as s, PIPELINE_HEADER as t, SessionFact as u, TransformSessionContext as v };

package/package.json

@@ -1,6 +1,49 @@
 {
   "name": "@skaile/transform-proxy",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "type": "module",
+  "description": "Same-protocol passthrough proxy that runs model requests and replies through a chain of text transforms (Anthropic Messages, OpenAI chat, OpenAI responses)",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/skaile-ai/skaile-transform-proxy.git"
+  },
+  "homepage": "https://github.com/skaile-ai/skaile-transform-proxy#readme",
+  "bugs": {
+    "url": "https://github.com/skaile-ai/skaile-transform-proxy/issues"
+  },
+  "keywords": ["llm", "proxy", "anthropic", "openai", "anonymization", "transform"],
+  "engines": {
+    "node": ">=22"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "bin": {
+    "skaile-transform-proxy": "dist/cli.mjs"
+  },
+  "files": ["dist", "README.md", "CHANGELOG.md", "LICENSE"],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "prebuild": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\"",
+    "build": "tsdown",
+    "prepare": "npm run build",
+    "test": "bun test",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "yaml": "^2.9.0"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.3.0",
+    "@types/node": "^22.0.0",
+    "tsdown": "^0.23.1",
+    "typescript": "^5.9.3"
+  }
+}