@neutrome/lilsdk 0.4.4 → 0.4.6

package/src/managed/two-pass-request.ts

@@ -1,164 +0,0 @@
-import {
-  appendInstructions,
-  contentText,
-  insertBefore,
-  messageText,
-  messages,
-  removeRange,
-  type Program,
-} from "@neutrome/lil-engine";
-import { Opcode } from "@neutrome/lil-engine";
-import {
-  appendToolInteraction,
-  makeMessage,
-  prependSystemPrompt,
-} from "../synthetic/index.ts";
-import type { ExecutorContext } from "../types.ts";
-
-export const INTERNAL_DRAFT_TOOL_NAME = "knowledge";
-export const INTERNAL_DRAFT_CALL_ID = "knowledge_0";
-
-export type InternalDraft =
-  | string
-  | readonly string[]
-  | readonly { text: string }[];
-
-export type TwoPassSettings = {
-  reasoningLevel?: string;
-  systemPrompt?: string;
-};
-
-export type TwoPassSettingsResolver = (
-  request: Program,
-  ctx: ExecutorContext,
-) => TwoPassSettings | null | Promise<TwoPassSettings | null>;
-
-export type TwoPassRequestOptions = {
-  maxTotalContextLength?: number;
-  buildFinalRequest?: (request: Program, draft: string) => Program;
-};
-
-export function appendInternalDraft(
-  request: Program,
-  draft: InternalDraft,
-  options: { callId?: string } = {},
-): Program {
-  const callId = options.callId ?? INTERNAL_DRAFT_CALL_ID;
-  const drafts = normalizeDrafts(draft);
-  if (drafts.length === 0) return request;
-  return drafts.reduce(
-    (program, text, index) =>
-      appendToolInteraction(program, {
-        callId: drafts.length === 1 ? callId : `${callId}_${index}`,
-        name: INTERNAL_DRAFT_TOOL_NAME,
-        args: {},
-        result: text,
-      }),
-    request,
-  );
-}
-
-export function buildDraftRequest(
-  request: Program,
-  settings: TwoPassSettings,
-): Program {
-  const withPrompt = settings.systemPrompt
-    ? replaceSystemPrompt(request, settings.systemPrompt)
-    : request;
-  return applySettings(withPrompt, settings);
-}
-
-export function buildFinalRequest(
-  options: TwoPassRequestOptions,
-  request: Program,
-  settings: TwoPassSettings,
-  draft: string,
-): Program {
-  const limitedDraft = limitDraft(options, request, settings, draft);
-  const withDraft = options.buildFinalRequest
-    ? options.buildFinalRequest(request, limitedDraft)
-    : appendInternalDraft(request, limitedDraft);
-  const withPrompt = settings.systemPrompt
-    ? prependSystemPrompt(withDraft, settings.systemPrompt)
-    : withDraft;
-  return applySettings(withPrompt, settings);
-}
-
-export function validateMaxContextLength(value: number | undefined): void {
-  if (value !== undefined && (!Number.isSafeInteger(value) || value < 0)) {
-    throw new Error("maxTotalContextLength must be a non-negative integer");
-  }
-}
-
-function replaceSystemPrompt(request: Program, systemPrompt: string): Program {
-  const systemSpans = messages(request).filter(
-    (span) => span.role === "system",
-  );
-  const previousSystemPrompt = systemSpans
-    .map((span) => messageText(request, span).trim())
-    .filter(Boolean)
-    .join("\n\n");
-  let draft = request;
-  for (const span of systemSpans.slice().reverse()) {
-    draft = removeRange(draft, span.start, span.end);
-  }
-  draft = prependSystemPrompt(draft, systemPrompt);
-  if (!previousSystemPrompt) return draft;
-  const firstNonSystem = messages(draft).find((span) => span.role !== "system");
-  return insertBefore(
-    draft,
-    firstNonSystem?.start ?? draft.code.length,
-    makeMessage("user", previousSystemPrompt).code,
-  );
-}
-
-function applySettings(request: Program, settings: TwoPassSettings): Program {
-  if (!settings.reasoningLevel) return request;
-  return appendInstructions(
-    {
-      ...request,
-      code: request.code.filter(
-        (instruction) => instruction.opcode !== Opcode.SET_REASON_EFFORT,
-      ),
-    },
-    [
-      {
-        opcode: Opcode.SET_REASON_EFFORT,
-        value: { kind: "string", value: settings.reasoningLevel },
-      },
-    ],
-  );
-}
-
-function limitDraft(
-  options: TwoPassRequestOptions,
-  request: Program,
-  settings: TwoPassSettings,
-  draft: string,
-): string {
-  if (options.maxTotalContextLength === undefined) return draft;
-  const base = buildFinalRequestWithoutDraft(options, request, settings);
-  const available = options.maxTotalContextLength - contentText(base).length;
-  return available > 0 ? draft.slice(0, available) : "";
-}
-
-function buildFinalRequestWithoutDraft(
-  options: TwoPassRequestOptions,
-  request: Program,
-  settings: TwoPassSettings,
-): Program {
-  const withDraft = options.buildFinalRequest
-    ? options.buildFinalRequest(request, "")
-    : request;
-  const withPrompt = settings.systemPrompt
-    ? prependSystemPrompt(withDraft, settings.systemPrompt)
-    : withDraft;
-  return applySettings(withPrompt, settings);
-}
-
-function normalizeDrafts(draft: InternalDraft): string[] {
-  const drafts = Array.isArray(draft)
-    ? draft.map((item) => (typeof item === "string" ? item : item.text))
-    : [draft];
-  return drafts.map((text) => text.trim()).filter((text) => text.length > 0);
-}

package/src/managed/two-pass.ts

@@ -1,171 +0,0 @@
-import {
-  callData,
-  contentText,
-  createProgram,
-  deltaText,
-  finishReason,
-  hasToolDelta,
-  lastMessageRole,
-  type Program,
-} from "@neutrome/lil-engine";
-import { streamReasoningDelta } from "../output.ts";
-import { completeStream, streamStage } from "../stream/stages.ts";
-import type { Executor, ExecutorContext, ExecutorInput } from "../types.ts";
-import {
-  appendInternalDraft,
-  buildDraftRequest,
-  buildFinalRequest,
-  INTERNAL_DRAFT_CALL_ID,
-  INTERNAL_DRAFT_TOOL_NAME,
-  validateMaxContextLength,
-  type InternalDraft,
-  type TwoPassRequestOptions,
-  type TwoPassSettings,
-  type TwoPassSettingsResolver,
-} from "./two-pass-request.ts";
-
-export type {
-  InternalDraft,
-  TwoPassSettings,
-  TwoPassSettingsResolver,
-} from "./two-pass-request.ts";
-export {
-  appendInternalDraft,
-  INTERNAL_DRAFT_CALL_ID,
-  INTERNAL_DRAFT_TOOL_NAME,
-};
-
-export type TwoPassExecutorOptions = TwoPassRequestOptions & {
-  draft: ExecutorInput;
-  final: ExecutorInput;
-  resolveDraftSettings?: TwoPassSettingsResolver;
-  resolveFinalSettings?: TwoPassSettingsResolver;
-  reasoningIntro?: string;
-  reasoningSeparator?: string;
-};
-
-export function createTwoPassExecutor(
-  options: TwoPassExecutorOptions,
-): Executor {
-  const reasoningIntro = options.reasoningIntro ?? "Let me think...\n\n";
-  const reasoningSeparator = options.reasoningSeparator ?? "\n\n";
-  validateMaxContextLength(options.maxTotalContextLength);
-
-  return {
-    async execute(request, ctx) {
-      const settings = await resolveSettings(options, request, ctx);
-      if (!settings.draft) {
-        return invokeFinal(options, request, ctx, settings.final!);
-      }
-      const draftRequest = buildDraftRequest(request, settings.draft);
-      if (!settings.final || lastMessageRole(request) === "tool") {
-        return ctx.invoke(options.draft, draftRequest);
-      }
-
-      const draftResponse = await ctx.invoke(options.draft, draftRequest);
-      if (callData(draftResponse).length > 0) return draftResponse;
-
-      return invokeFinal(
-        options,
-        request,
-        ctx,
-        settings.final,
-        contentText(draftResponse),
-      );
-    },
-
-    async *stream(request, ctx) {
-      const settings = await resolveSettings(options, request, ctx);
-      if (!settings.draft) {
-        yield* streamFinal(options, request, ctx, settings.final!);
-        return;
-      }
-      const draftRequest = buildDraftRequest(request, settings.draft);
-      if (!settings.final || lastMessageRole(request) === "tool") {
-        yield* ctx.invokeStream(options.draft, draftRequest);
-        return;
-      }
-
-      let transcript = "";
-      let emittedReasoning = false;
-      let toolMode = false;
-      for await (const chunk of streamStage(
-        ctx.invokeStream(options.draft, draftRequest),
-      )) {
-        if (ctx.signal.aborted) return;
-        if (toolMode) {
-          yield chunk;
-          continue;
-        }
-        if (hasToolDelta(chunk) || finishReason(chunk) === "tool_calls") {
-          toolMode = true;
-          yield chunk;
-          continue;
-        }
-        const text = deltaText(chunk);
-        if (!text) continue;
-        transcript += text;
-        if (!emittedReasoning) {
-          emittedReasoning = true;
-          yield streamReasoningDelta(reasoningIntro);
-        }
-        yield streamReasoningDelta(text);
-      }
-
-      if (ctx.signal.aborted) return;
-      if (toolMode) {
-        yield completeStream("tool_calls");
-        return;
-      }
-      if (emittedReasoning && reasoningSeparator) {
-        yield streamReasoningDelta(reasoningSeparator);
-      }
-      yield* streamFinal(options, request, ctx, settings.final, transcript);
-    },
-  };
-}
-
-async function resolveSettings(
-  options: TwoPassExecutorOptions,
-  request: Program,
-  ctx: ExecutorContext,
-): Promise<{ draft: TwoPassSettings | null; final: TwoPassSettings | null }> {
-  const [draft, final] = await Promise.all([
-    options.resolveDraftSettings
-      ? options.resolveDraftSettings(request, ctx)
-      : {},
-    options.resolveFinalSettings
-      ? options.resolveFinalSettings(request, ctx)
-      : {},
-  ]);
-  if (!draft && !final) {
-    throw new Error("Two-pass executor requires at least one enabled pass");
-  }
-  return { draft, final };
-}
-
-function invokeFinal(
-  options: TwoPassExecutorOptions,
-  request: Program,
-  ctx: ExecutorContext,
-  settings: TwoPassSettings,
-  draft = "",
-): Promise<Program> {
-  return ctx.invoke(
-    options.final,
-    buildFinalRequest(options, request, settings, draft),
-  );
-}
-
-async function* streamFinal(
-  options: TwoPassExecutorOptions,
-  request: Program,
-  ctx: ExecutorContext,
-  settings: TwoPassSettings,
-  draft = "",
-): AsyncIterable<Program> {
-  yield* ctx.invokeStream(
-    options.final,
-    buildFinalRequest(options, request, settings, draft),
-  );
-}