sailfork / t3code-github / packages/ provider-muse/ src/ server/ textGeneration.ts

import {
  DEFAULT_TEXT_GENERATION_REASONING_EFFORT,
  MUSE_DEFAULT_MODEL,
  type ModelSelection,
  type ServerProviderModel,
  TextGenerationError,
} from "@t3tools/contracts";
import type { MuseSettings } from "../settings.ts";
import { sanitizeBranchFragment, sanitizeFeatureBranchName } from "@t3tools/shared/git";
import { getModelSelectionStringOptionValue } from "@t3tools/shared/model";
import { extractJsonObject } from "@t3tools/shared/schemaJson";
import * as Effect from "effect/Effect";
import * as FileSystem from "effect/FileSystem";
import * as Option from "effect/Option";
import * as Schema from "effect/Schema";

import {
  createMuseSdkHost,
  createMuseSdkHostEffect,
  MuseSdkError,
  type MuseSdkHost,
} from "./sdk.ts";
import { museModelCapabilities, resolveMuseReasoningEffort } from "./modelCatalog.ts";
import type { ProviderTextGeneration } from "@t3tools/provider-core/server/textGeneration";
import {
  investigationUnsupported,
  TranscriptionPostProcessingOutput,
} from "@t3tools/provider-core/server/textGenerationOperations";
import {
  buildBranchNamePrompt,
  buildCommitMessagePrompt,
  buildPrContentPrompt,
  buildThreadTitlePrompt,
} from "@t3tools/provider-core/server/textGenerationPrompts";
import {
  sanitizeCommitSubject,
  sanitizePrTitle,
  sanitizeThreadTitle,
  toJsonSchemaObject,
} from "@t3tools/provider-core/server/textGenerationUtils";

const SessionStarted = Schema.Struct({ session: Schema.Struct({ sessionId: Schema.String }) });
const ItemNotification = Schema.Struct({
  sessionId: Schema.String,
  item: Schema.Struct({
    itemId: Schema.String,
    kind: Schema.String,
    revision: Schema.Int,
    turnId: Schema.optionalKey(Schema.String),
    text: Schema.optionalKey(Schema.String),
    retracted: Schema.optionalKey(Schema.Boolean),
    truncated: Schema.optionalKey(Schema.Boolean),
  }),
});
const TurnCompleted = Schema.Struct({
  sessionId: Schema.String,
  turnId: Schema.String,
  terminal: Schema.String,
  error: Schema.optionalKey(Schema.Struct({ message: Schema.String })),
});
const ApprovalRequested = Schema.Struct({
  sessionId: Schema.String,
  approvalId: Schema.String,
  currentRequirementId: Schema.Unknown,
  availableChoices: Schema.Array(
    Schema.Struct({ choiceId: Schema.String, decision: Schema.String }),
  ),
});
const UserInputRequested = Schema.Struct({
  sessionId: Schema.String,
  userInputId: Schema.String,
});
const decodeSession = Schema.decodeUnknownSync(SessionStarted);
const decodeItem = Schema.decodeUnknownSync(ItemNotification);
const decodeCompleted = Schema.decodeUnknownSync(TurnCompleted);
const decodeApproval = Schema.decodeUnknownSync(ApprovalRequested);
const decodeUserInput = Schema.decodeUnknownSync(UserInputRequested);
const encodeJson = Schema.encodeEffect(Schema.fromJsonString(Schema.Unknown));
const decodeJson = Schema.decodeEffect(Schema.fromJsonString(Schema.Unknown));

type Operation = keyof ProviderTextGeneration;

async function generateMuseText(
  host: MuseSdkHost,
  workspaceRoot: string,
  prompt: string,
  modelId: string | undefined,
  reasoningEffort: string | undefined,
  signal: AbortSignal,
) {
  let sessionId: string | undefined;
  const turnId = host.connection.mintCommandId();
  const messages = new Map<string, (typeof ItemNotification.Type)["item"]>();
  let resolveCompletion: (text: string) => void = () => {};
  let rejectCompletion: (error: unknown) => void = () => {};
  const completion = new Promise<string>((resolve, reject) => {
    resolveCompletion = resolve;
    rejectCompletion = reject;
  });
  // Notifications may settle the turn before the turn/start acknowledgement arrives.
  void completion.catch(() => {});
  const rejectInteractive = async (method: string, params: Record<string, unknown>) => {
    if (method === "approval/requested") {
      const approval = decodeApproval(params);
      if (approval.sessionId !== sessionId) return;
      rejectCompletion(new Error("Muse requested an interactive action during text generation."));
      const deny = approval.availableChoices.find((choice) => choice.decision === "denied");
      if (deny) {
        await host.connection.command("approval/decide", {
          sessionId,
          approvalId: approval.approvalId,
          requirementId: approval.currentRequirementId,
          choiceId: deny.choiceId,
        });
      }
    } else {
      const request = decodeUserInput(params);
      if (request.sessionId !== sessionId) return;
      rejectCompletion(new Error("Muse requested an interactive action during text generation."));
      await host.connection.command("userInput/cancel", {
        sessionId,
        userInputId: request.userInputId,
        reason: "T3 Code text generation cannot request user input.",
      });
    }
  };
  host.connection.onNotification((notification) => {
    try {
      if (notification.method === "item/completed" || notification.method === "item/updated") {
        const { item, sessionId: itemSessionId } = decodeItem(notification.params);
        if (itemSessionId !== sessionId || item.turnId !== turnId || item.kind !== "agentMessage")
          return;
        const previous = messages.get(item.itemId);
        if (!previous || item.revision > previous.revision) messages.set(item.itemId, item);
      } else if (notification.method === "turn/completed") {
        const completed = decodeCompleted(notification.params);
        if (completed.sessionId !== sessionId || completed.turnId !== turnId) return;
        if (completed.terminal === "completed") {
          // A turn may include commentary before its final structured answer.
          const answer = [...messages.values()].findLast((item) => !item.retracted);
          if (answer?.truncated) {
            rejectCompletion(new Error("Muse text generation returned a truncated response."));
          } else {
            resolveCompletion(answer?.text ?? "");
          }
        } else {
          rejectCompletion(
            new Error(completed.error?.message ?? `Muse turn ${completed.terminal}.`),
          );
        }
      } else if (
        notification.method === "approval/requested" ||
        notification.method === "userInput/requested"
      ) {
        void rejectInteractive(notification.method, notification.params ?? {}).catch(
          rejectCompletion,
        );
      } else if (notification.method === "view/gap") {
        rejectCompletion(new Error("Muse text generation lost part of its response."));
      }
    } catch (error) {
      rejectCompletion(error);
    }
  });
  host.connection.onProtocolError(rejectCompletion);
  host.connection.onServerRequest(async () => {
    const error = new Error("T3 Code text generation cannot approve interactive requests.");
    rejectCompletion(error);
    throw error;
  });
  void host.connection.closed.then(() => {
    rejectCompletion(new Error("Muse connection closed before text generation completed."));
  });
  void host.exited.then(() => {
    rejectCompletion(new Error("Muse exited before text generation completed."));
  });
  const onAbort = () => rejectCompletion(signal.reason);
  signal.addEventListener("abort", onAbort, { once: true });
  try {
    signal.throwIfAborted();
    const started = decodeSession(
      await host.connection.command("session/start", {
        workspaceRoot,
        providerId: "meta",
        ...(modelId ? { modelId } : {}),
        approvalMode: "denyUnmatched",
      }),
    );
    sessionId = started.session.sessionId;
    const acknowledged = host.connection.command(
      "turn/start",
      {
        sessionId,
        input: [{ type: "text", text: prompt }],
        ...(reasoningEffort !== undefined ? { reasoningEffort } : {}),
      },
      { commandId: turnId },
    );
    return await Promise.race([acknowledged.then(() => completion), completion]);
  } finally {
    signal.removeEventListener("abort", onAbort);
  }
}

export const makeMuseTextGeneration = Effect.fn("makeMuseTextGeneration")(function* (
  settings: MuseSettings,
  options: {
    readonly environment?: NodeJS.ProcessEnv;
    readonly modelCatalog?: Effect.Effect<ReadonlyArray<ServerProviderModel>>;
    readonly createHost?: typeof createMuseSdkHost;
  } = {},
) {
  const { environment, modelCatalog = Effect.succeed([]), createHost } = options;
  const fileSystem = yield* FileSystem.FileSystem;
  const runMuseJson = Effect.fn("runMuseJson")(function* <S extends Schema.Top>(input: {
    operation: Operation;
    prompt: string;
    outputSchema: S;
    modelSelection: ModelSelection;
  }): Effect.fn.Return<S["Type"], TextGenerationError, S["DecodingServices"]> {
    const { operation } = input;
    if (!settings.enabled) {
      return yield* new TextGenerationError({ operation, detail: "Muse Code is disabled." });
    }
    const selectedModel = input.modelSelection.model.trim();
    const models = yield* modelCatalog;
    const catalogModel =
      selectedModel && selectedModel !== MUSE_DEFAULT_MODEL
        ? models.find((model) => model.slug === selectedModel)
        : models.find((model) => model.isDefault && !model.isCustom);
    const modelId =
      selectedModel && selectedModel !== MUSE_DEFAULT_MODEL ? selectedModel : catalogModel?.slug;
    const reasoningEffort = resolveMuseReasoningEffort(
      catalogModel?.capabilities ?? museModelCapabilities(),
      getModelSelectionStringOptionValue(input.modelSelection, "reasoningEffort") ??
        DEFAULT_TEXT_GENERATION_REASONING_EFFORT,
    );
    const jsonSchema = yield* encodeJson(toJsonSchemaObject(input.outputSchema)).pipe(
      Effect.mapError(
        (cause) => new TextGenerationError({ operation, detail: "Invalid output schema.", cause }),
      ),
    );
    const response = yield* Effect.gen(function* () {
      // Metadata requests already include their context and do not need checkout configuration.
      const cwd = yield* fileSystem.makeTempDirectoryScoped({ prefix: "t3code-muse-text-" });
      const host = yield* Effect.acquireRelease(
        createMuseSdkHostEffect(
          {
            binaryPath: settings.binaryPath,
            cwd,
            ...(environment ? { environment } : {}),
            readOnly: true,
            // Muse derives SDK turn events from its session log, including completion.
            sessionLogging: true,
          },
          createHost,
        ),
        (host: MuseSdkHost) => Effect.promise(() => host.close()),
        { interruptible: true },
      );
      return yield* Effect.tryPromise({
        try: (signal) =>
          generateMuseText(
            host,
            cwd,
            `${input.prompt}\n\nReturn only a JSON object matching this schema, with no markdown fences. Do not use tools or ask questions.\n${jsonSchema}`,
            modelId,
            reasoningEffort,
            signal,
          ),
        catch: (cause) => new MuseSdkError({ operation: "generate text", cause }),
      });
    }).pipe(
      Effect.scoped,
      Effect.mapError(
        (cause) =>
          new TextGenerationError({
            operation,
            detail:
              "Muse Code text generation failed. Check Muse login and availability on this T3 server host.",
            cause,
          }),
      ),
      Effect.timeoutOption(180_000),
      Effect.flatMap(
        Option.match({
          onNone: () =>
            Effect.fail(new TextGenerationError({ operation, detail: "Muse request timed out." })),
          onSome: Effect.succeed,
        }),
      ),
    );
    const decodeOutput = Schema.decodeEffect(input.outputSchema);
    return yield* decodeJson(extractJsonObject(response)).pipe(
      Effect.flatMap(decodeOutput),
      Effect.mapError(
        (cause) =>
          new TextGenerationError({
            operation,
            detail: "Muse returned invalid structured output.",
            cause,
          }),
      ),
    );
  });

  const generateCommitMessage: ProviderTextGeneration["generateCommitMessage"] = Effect.fn(
    "MuseTextGeneration.generateCommitMessage",
  )(function* (input) {
    const generated = yield* runMuseJson({
      operation: "generateCommitMessage",
      ...buildCommitMessagePrompt({ ...input, includeBranch: input.includeBranch === true }),
      modelSelection: input.modelSelection,
    });
    return {
      subject: sanitizeCommitSubject(generated.subject),
      body: generated.body.trim(),
      ...("branch" in generated && typeof generated.branch === "string"
        ? { branch: sanitizeFeatureBranchName(generated.branch) }
        : {}),
    };
  });
  const generatePrContent: ProviderTextGeneration["generatePrContent"] = Effect.fn(
    "MuseTextGeneration.generatePrContent",
  )(function* (input) {
    const generated = yield* runMuseJson({
      operation: "generatePrContent",
      ...buildPrContentPrompt(input),
      modelSelection: input.modelSelection,
    });
    return { title: sanitizePrTitle(generated.title), body: generated.body.trim() };
  });
  const generateBranchName: ProviderTextGeneration["generateBranchName"] = Effect.fn(
    "MuseTextGeneration.generateBranchName",
  )(function* (input) {
    const generated = yield* runMuseJson({
      operation: "generateBranchName",
      ...buildBranchNamePrompt(input),
      modelSelection: input.modelSelection,
    });
    return { branch: sanitizeBranchFragment(generated.branch) };
  });
  const generateThreadTitle: ProviderTextGeneration["generateThreadTitle"] = Effect.fn(
    "MuseTextGeneration.generateThreadTitle",
  )(function* (input) {
    const generated = yield* runMuseJson({
      operation: "generateThreadTitle",
      ...buildThreadTitlePrompt(input),
      modelSelection: input.modelSelection,
    });
    return { title: sanitizeThreadTitle(generated.title) };
  });
  const generateTranscriptionPostProcessing: ProviderTextGeneration["generateTranscriptionPostProcessing"] =
    Effect.fn("MuseTextGeneration.generateTranscriptionPostProcessing")(function* (input) {
      return yield* runMuseJson({
        operation: "generateTranscriptionPostProcessing",
        prompt: input.prompt,
        outputSchema: TranscriptionPostProcessingOutput,
        modelSelection: input.modelSelection,
      });
    });
  const generateReviewGuide: ProviderTextGeneration["generateReviewGuide"] = () =>
    Effect.fail(investigationUnsupported("generateReviewGuide", "Muse Code"));
  return {
    generateCommitMessage,
    generatePrContent,
    generateBranchName,
    generateThreadTitle,
    generateReviewGuide,
    generateTranscriptionPostProcessing,
  } satisfies ProviderTextGeneration;
});