@intx/inference 0.1.2 → 0.2.2

package/src/transform.ts

@@ -1,159 +0,0 @@
-// Cross-provider message transformation.
-//
-// When conversations cross provider boundaries the message history must be
-// adapted: thinking blocks are stripped for foreign models, orphaned tool
-// calls receive synthetic error results, and tool call IDs are normalized to
-// a portable format.
-//
-// Transformation runs automatically when the target model differs from a
-// message's originating model. The originating model is tracked per-message,
-// not per-conversation.
-
-import type { ConversationTurn, ContentBlock } from "@intx/types/runtime";
-
-export type TransformOptions = {
-  targetModel: string;
-  // When true, keep thinking blocks for messages that originated from the
-  // same model. When false, strip all thinking blocks (cross-provider replay).
-  keepThinkingForSameModel?: boolean;
-};
-
-export function transformMessages(
-  messages: ConversationTurn[],
-  options: TransformOptions,
-): ConversationTurn[] {
-  const { targetModel, keepThinkingForSameModel = true } = options;
-
-  // First pass: strip thinking blocks and filter aborted assistant messages.
-  const filtered = messages
-    .map((msg): ConversationTurn | null => {
-      if (msg.role === "assistant") {
-        const isSameModel = msg.model === targetModel;
-        const keepThinking = keepThinkingForSameModel && isSameModel;
-
-        const filteredContent = msg.content.filter((block) => {
-          if (block.type === "thinking") {
-            return keepThinking;
-          }
-          return true;
-        });
-
-        // Filter out assistant messages that have no text or tool calls
-        // (aborted/error messages with only thinking blocks removed).
-        const hasUsableContent = filteredContent.some(
-          (b) => b.type === "text" || b.type === "tool_call",
-        );
-        if (!hasUsableContent && filteredContent.length === 0) {
-          return null;
-        }
-
-        return { ...msg, content: filteredContent };
-      }
-      return msg;
-    })
-    .filter((msg): msg is ConversationTurn => msg !== null);
-
-  // Second pass: inject synthetic tool results for orphaned tool calls.
-  return injectOrphanedToolResults(filtered);
-}
-
-function injectOrphanedToolResults(
-  messages: ConversationTurn[],
-): ConversationTurn[] {
-  const result: ConversationTurn[] = [];
-
-  for (let i = 0; i < messages.length; i++) {
-    const msg = messages[i];
-    if (msg === undefined) continue;
-    result.push(msg);
-
-    if (msg.role !== "assistant") continue;
-
-    const toolCalls = msg.content.filter(
-      (b): b is Extract<ContentBlock, { type: "tool_call" }> =>
-        b.type === "tool_call",
-    );
-
-    if (toolCalls.length === 0) continue;
-
-    // Collect tool call IDs from this assistant message.
-    const calledIds = new Set(toolCalls.map((tc) => tc.id));
-
-    // Check the following messages for results that cover these calls.
-    const coveredIds = new Set<string>();
-    for (let j = i + 1; j < messages.length; j++) {
-      const next = messages[j];
-      if (next === undefined) break;
-      if (next.role !== "user") break;
-
-      for (const block of next.content) {
-        if (block.type === "tool_result") {
-          coveredIds.add(block.callId);
-        }
-      }
-    }
-
-    // Find which tool calls have no corresponding result.
-    const orphanedIds = [...calledIds].filter((id) => !coveredIds.has(id));
-
-    if (orphanedIds.length === 0) continue;
-
-    // Inject a synthetic user message with error tool results for each orphan.
-    const syntheticBlocks: ContentBlock[] = orphanedIds.map((id) => ({
-      type: "tool_result" as const,
-      callId: id,
-      content: [
-        {
-          type: "text" as const,
-          text: "Tool execution was interrupted before completion.",
-        },
-      ],
-      isError: true,
-    }));
-
-    result.push({
-      role: "user",
-      content: syntheticBlocks,
-      timestamp: Date.now(),
-    });
-  }
-
-  return result;
-}
-
-// ---------------------------------------------------------------------------
-// Tool call ID normalization
-//
-// OpenAI Responses API generates 450+ character IDs with pipes. Anthropic
-// has strict format requirements. IDs are normalized to a short portable
-// format with a bidirectional map for round-trip fidelity.
-// ---------------------------------------------------------------------------
-
-const PORTABLE_ID_PREFIX = "tc_";
-
-export type IDNormalizer = {
-  normalize(providerId: string): string;
-  resolve(portableId: string): string | undefined;
-};
-
-export function createIDNormalizer(): IDNormalizer {
-  const portableToProvider = new Map<string, string>();
-  const providerToPortable = new Map<string, string>();
-  let counter = 0;
-
-  return {
-    normalize(providerId: string): string {
-      const existing = providerToPortable.get(providerId);
-      if (existing !== undefined) return existing;
-
-      const portable = `${PORTABLE_ID_PREFIX}${(++counter).toString(36)}`;
-      providerToPortable.set(providerId, portable);
-      portableToProvider.set(portable, providerId);
-      return portable;
-    },
-
-    resolve(portableId: string): string | undefined {
-      return portableToProvider.get(portableId);
-    },
-  };
-}

package/src/transforms/index.ts

@@ -1,2 +0,0 @@
-export { createSizeCapTransform } from "./size-cap";
-export type { SizeCapTransformOptions } from "./size-cap";

package/src/transforms/size-cap.test.ts

@@ -1,172 +0,0 @@
-import { describe, test, expect } from "bun:test";
-
-import { createSizeCapTransform } from "./size-cap";
-import type {
-  ContextStore,
-  ReactorState,
-  StrategyContext,
-  ToolCall,
-  ToolResult,
-} from "@intx/types/runtime";
-
-function emptyState(): ReactorState {
-  return {
-    turns: [],
-    activeForks: [],
-    pendingOperations: [],
-    activeGates: [],
-    tokenUsage: {
-      input: 0,
-      output: 0,
-      cacheRead: 0,
-      cacheWrite: 0,
-      thinking: 0,
-    },
-    lastCycleUsage: null,
-    lastCycleSource: null,
-    sessionId: "test-session",
-  };
-}
-
-function emptyContext(): StrategyContext {
-  return { state: emptyState(), trigger: "test" };
-}
-
-function recordingWriteBlob(): {
-  store: Pick<ContextStore, "writeBlob">;
-  calls: { key: string; bytes: Uint8Array; contentType?: string }[];
-} {
-  const calls: { key: string; bytes: Uint8Array; contentType?: string }[] = [];
-  const store: Pick<ContextStore, "writeBlob"> = {
-    async writeBlob(key, bytes, contentType) {
-      calls.push({
-        key,
-        bytes,
-        ...(contentType !== undefined ? { contentType } : {}),
-      });
-    },
-  };
-  return { store, calls };
-}
-
-function call(id: string, name = "tool"): ToolCall {
-  return { id, name, arguments: {} };
-}
-
-describe("createSizeCapTransform", () => {
-  test("passes a within-cap result through unchanged with a within-cap record", async () => {
-    const { store, calls } = recordingWriteBlob();
-    const transform = createSizeCapTransform({
-      maxChars: 100,
-      contextStore: store,
-    });
-
-    const result: ToolResult = { callId: "c1", content: "hello world" };
-    const out = await transform.apply(
-      { call: call("c1"), result },
-      emptyContext(),
-    );
-
-    expect(out.output).toBe(result);
-    expect(out.record.strategy).toBe("size-cap");
-    expect(out.record.reason).toBe("within-cap");
-    expect(out.record.decisions["callId"]).toBe("c1");
-    expect(out.record.decisions["length"]).toBe(11);
-    expect(out.blobs).toBeUndefined();
-    expect(calls).toHaveLength(0);
-  });
-
-  test("oversize result writes a blob and produces a truncated marker", async () => {
-    const { store, calls } = recordingWriteBlob();
-    const transform = createSizeCapTransform({
-      maxChars: 10,
-      contextStore: store,
-    });
-
-    const full = "x".repeat(50);
-    const result: ToolResult = { callId: "callABC", content: full };
-    const out = await transform.apply(
-      { call: call("callABC"), result },
-      emptyContext(),
-    );
-
-    expect(out.output).not.toBe(result);
-    const content = out.output.content;
-    if (typeof content !== "string") throw new Error("expected string content");
-    expect(content.startsWith("xxxxxxxxxx\n")).toBe(true);
-    expect(content).toContain("tool-output:///callABC");
-    expect(content).toContain("omitted 40 chars");
-    expect(out.record.strategy).toBe("size-cap");
-    expect(out.record.reason).toBe("exceeded-cap");
-    expect(out.record.decisions["callId"]).toBe("callABC");
-    expect(out.record.decisions["originalLength"]).toBe(50);
-    expect(out.record.decisions["kept"]).toBe(10);
-    expect(out.record.decisions["spillKey"]).toBe("callABC");
-    expect(out.record.decisions["spillURI"]).toBe("tool-output:///callABC");
-
-    // Blob is emitted for the reactor to persist.
-    expect(out.blobs).toBeDefined();
-    expect(out.blobs).toHaveLength(1);
-    expect(out.blobs?.[0]?.key).toBe("callABC");
-    expect(out.blobs?.[0]?.contentType).toBe("text/plain");
-
-    // The transform itself also wrote the blob through the supplied store
-    // (so reactors that consume blobs from the chain stay consistent with
-    // the transform's contract).
-    expect(calls).toHaveLength(1);
-    expect(calls[0]?.key).toBe("callABC");
-    expect(calls[0]?.contentType).toBe("text/plain");
-    expect(new TextDecoder().decode(calls[0]?.bytes)).toBe(full);
-  });
-
-  test("structured (non-string) content is JSON-stringified before length check", async () => {
-    const { store } = recordingWriteBlob();
-    const transform = createSizeCapTransform({
-      maxChars: 5,
-      contextStore: store,
-    });
-
-    const result: ToolResult = {
-      callId: "json-1",
-      content: { hello: "world", n: 42 },
-    };
-    const out = await transform.apply(
-      { call: call("json-1"), result },
-      emptyContext(),
-    );
-    expect(out.record.reason).toBe("exceeded-cap");
-  });
-
-  test("preserves isError and detail on the transformed output", async () => {
-    const { store } = recordingWriteBlob();
-    const transform = createSizeCapTransform({
-      maxChars: 4,
-      contextStore: store,
-    });
-
-    const result: ToolResult = {
-      callId: "x1",
-      content: "abcdefghij",
-      isError: true,
-      detail: { stack: "..." },
-    };
-    const out = await transform.apply(
-      { call: call("x1"), result },
-      emptyContext(),
-    );
-
-    expect(out.output.isError).toBe(true);
-    expect(out.output.detail).toEqual({ stack: "..." });
-  });
-
-  test("rejects non-positive maxChars at construction time", () => {
-    const { store } = recordingWriteBlob();
-    let thrown: Error | undefined;
-    try {
-      createSizeCapTransform({ maxChars: 0, contextStore: store });
-    } catch (cause) {
-      thrown = cause instanceof Error ? cause : new Error(String(cause));
-    }
-    expect(thrown?.message).toContain("positive finite");
-  });
-});

package/src/transforms/size-cap.ts

@@ -1,110 +0,0 @@
-// Tool-result size-cap transform.
-//
-// When a tool result's content exceeds `maxChars`, the full bytes are spilled
-// via `contextStore.writeBlob` and the inline result is replaced with the
-// first `maxChars` characters plus a marker pointing at the spill via a
-// `tool-output:///{callId}` URI. The agent's `read_file` tool resolves the
-// URI through its `BlobReader` capability.
-//
-// Within-cap results pass through unchanged (no blob is written) but still
-// produce a `TransformRecord` so the manifest captures every invocation.
-
-import type {
-  ContextStore,
-  StrategyContext,
-  StrategyResult,
-  ToolResult,
-  ToolResultTransform,
-} from "@intx/types/runtime";
-
-const SIZE_CAP_VERSION = "1";
-const SIZE_CAP_NAME = "size-cap";
-
-export type SizeCapTransformOptions = {
-  maxChars: number;
-  contextStore: Pick<ContextStore, "writeBlob">;
-};
-
-/**
- * Create a `ToolResultTransform` that caps inline tool result content at
- * `maxChars` characters. Oversized results are spilled to the context store
- * via `writeBlob` and the inline content becomes a truncated marker
- * referencing the spill by `tool-output:///{callId}` URI.
- */
-export function createSizeCapTransform(
-  options: SizeCapTransformOptions,
-): ToolResultTransform {
-  const { maxChars, contextStore } = options;
-  if (!Number.isFinite(maxChars) || maxChars <= 0) {
-    throw new Error(
-      `createSizeCapTransform: maxChars must be a positive finite number, got ${String(maxChars)}`,
-    );
-  }
-
-  return {
-    name: SIZE_CAP_NAME,
-    version: SIZE_CAP_VERSION,
-    async apply(
-      input: { call: { id: string; name: string }; result: ToolResult },
-      _ctx: StrategyContext,
-    ): Promise<StrategyResult<ToolResult>> {
-      const { call, result } = input;
-      const text =
-        typeof result.content === "string"
-          ? result.content
-          : JSON.stringify(result.content);
-
-      if (text.length <= maxChars) {
-        return {
-          output: result,
-          record: {
-            strategy: SIZE_CAP_NAME,
-            version: SIZE_CAP_VERSION,
-            parameters: { maxChars },
-            reason: "within-cap",
-            decisions: { callId: call.id, length: text.length },
-          },
-        };
-      }
-
-      const omitted = text.length - maxChars;
-      const kept = text.slice(0, maxChars);
-      const spillURI = `tool-output:///${call.id}`;
-      const marker =
-        `${kept}\n[Tool output truncated: omitted ${String(omitted)} chars. ` +
-        `Full output available at ${spillURI} -- use read_file with that URI to see the rest.]`;
-
-      const bytes = new TextEncoder().encode(text);
-      await contextStore.writeBlob(call.id, bytes, "text/plain");
-
-      const output: ToolResult = {
-        ...result,
-        content: marker,
-      };
-
-      return {
-        output,
-        record: {
-          strategy: SIZE_CAP_NAME,
-          version: SIZE_CAP_VERSION,
-          parameters: { maxChars },
-          reason: "exceeded-cap",
-          decisions: {
-            callId: call.id,
-            originalLength: text.length,
-            kept: maxChars,
-            spillKey: call.id,
-            spillURI,
-          },
-        },
-        blobs: [
-          {
-            key: call.id,
-            bytes,
-            contentType: "text/plain",
-          },
-        ],
-      };
-    },
-  };
-}

package/src/turns.ts

@@ -1,54 +0,0 @@
-import type {
-  ConversationTurn,
-  ContentBlock,
-  AssistantTurn,
-  InboundMessage,
-  ToolCall,
-  ToolResult,
-} from "@intx/types/runtime";
-
-export type { ConversationTurn, ContentBlock, AssistantTurn };
-
-export type { ToolCall, ToolResult };
-
-export function createInboundTurn(
-  message: InboundMessage,
-): ConversationTurn | null {
-  const content = message.content ?? "";
-  if (content.length === 0) return null;
-
-  const { from, subject } = message.headers;
-  const envelope: string[] = [];
-  if (from.length > 0) envelope.push(`[From: ${from}]`);
-  if (subject !== undefined && subject.length > 0) {
-    envelope.push(`[Subject: ${subject}]`);
-  }
-
-  const text =
-    envelope.length > 0 ? `${envelope.join("\n")}\n\n${content}` : content;
-  return {
-    role: "user",
-    content: [{ type: "text", text }],
-    timestamp: Date.now(),
-  };
-}
-
-export function createToolResultTurn(results: ToolResult[]): ConversationTurn {
-  const blocks: ContentBlock[] = results.map((r) => {
-    const raw =
-      typeof r.content === "string" ? r.content : JSON.stringify(r.content);
-    const block: Extract<ContentBlock, { type: "tool_result" }> = {
-      type: "tool_result",
-      callId: r.callId,
-      content: [{ type: "text" as const, text: raw }],
-    };
-    if (r.detail !== undefined) {
-      block.detail = r.detail;
-    }
-    if (r.isError !== undefined) {
-      block.isError = r.isError;
-    }
-    return block;
-  });
-  return { role: "user", content: blocks, timestamp: Date.now() };
-}

package/tsconfig.json

@@ -1,4 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "include": ["src/**/*.ts"]
-}