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

import * as Effect from "effect/Effect";
import * as Schema from "effect/Schema";

import { NonNegativeInt, settingsSecretLiteral, TextGenerationError } from "@t3tools/contracts";
import type { OpenCodeSettings } from "../settings.ts";
import { getModelSelectionStringOptionValue } from "@t3tools/shared/model";

import * as ProviderHost from "@t3tools/provider-core/server/ProviderHost";
import * as TextGenerationOperations from "@t3tools/provider-core/server/textGenerationOperations";
import * as OpenCodeRuntime from "./OpenCodeRuntime.ts";
import * as OpenCodeServerOwner from "./OpenCodeServerOwner.ts";

const GENERATION_TIMEOUT = "3 minutes";

const OpenCodeTextGenerationOperation = Schema.Literals([
  "generateCommitMessage",
  "generatePrContent",
  "generateBranchName",
  "generateThreadTitle",
  "generateReviewGuide",
  "generateTranscriptionPostProcessing",
]);

const openCodeTextGenerationErrorContext = {
  operation: OpenCodeTextGenerationOperation,
  cwd: Schema.String,
};

export class OpenCodeTextGenerationSessionRequestError extends Schema.TaggedError<OpenCodeTextGenerationSessionRequestError>()(
  "OpenCodeTextGenerationSessionRequestError",
  {
    ...openCodeTextGenerationErrorContext,
    cause: Schema.Defect(),
  },
) {
  override get message(): string {
    return `OpenCode session creation request failed for ${this.operation} in ${this.cwd}.`;
  }
}

export class OpenCodeTextGenerationSessionPayloadError extends Schema.TaggedError<OpenCodeTextGenerationSessionPayloadError>()(
  "OpenCodeTextGenerationSessionPayloadError",
  openCodeTextGenerationErrorContext,
) {
  override get message(): string {
    return `OpenCode session.create returned no session payload for ${this.operation} in ${this.cwd}.`;
  }
}

const openCodePromptErrorContext = {
  ...openCodeTextGenerationErrorContext,
  sessionId: Schema.String,
  providerId: Schema.String,
  modelId: Schema.String,
};

export class OpenCodeTextGenerationPromptRequestError extends Schema.TaggedError<OpenCodeTextGenerationPromptRequestError>()(
  "OpenCodeTextGenerationPromptRequestError",
  {
    ...openCodePromptErrorContext,
    cause: Schema.Defect(),
  },
) {
  override get message(): string {
    return `OpenCode prompt request failed for ${this.operation} in ${this.cwd} using ${this.providerId}/${this.modelId} (session ${this.sessionId}).`;
  }
}

export class OpenCodeTextGenerationPromptResponseError extends Schema.TaggedError<OpenCodeTextGenerationPromptResponseError>()(
  "OpenCodeTextGenerationPromptResponseError",
  {
    ...openCodePromptErrorContext,
    providerErrorName: Schema.optional(Schema.String),
    statusCode: Schema.optional(Schema.Int),
    cause: Schema.Defect(),
  },
) {
  override get message(): string {
    const providerError = this.providerErrorName ? ` ${this.providerErrorName}` : "";
    const status = this.statusCode === undefined ? "" : `, HTTP ${this.statusCode}`;
    return `OpenCode prompt${providerError} failed for ${this.operation} in ${this.cwd} using ${this.providerId}/${this.modelId} (session ${this.sessionId}${status}).`;
  }
}

function openCodePromptResponseErrorDetail(error: OpenCodeTextGenerationPromptResponseError) {
  if (
    error.providerErrorName === "ProviderAuthError" ||
    error.statusCode === 401 ||
    error.statusCode === 403
  ) {
    return "The model provider rejected the credentials. Check the provider's sign-in or API key in OpenCode.";
  }
  if (error.statusCode === 429) {
    return "The model provider's usage or rate limit was reached. Try again later.";
  }
  if (error.providerErrorName === "ContextOverflowError") {
    return "The prompt is too long for the selected model's context window.";
  }
  if (error.providerErrorName === "MessageAbortedError") {
    return "OpenCode stopped the generation.";
  }
  if (error.statusCode !== undefined) {
    return `The model provider failed the request (HTTP ${error.statusCode}).`;
  }
  return "OpenCode could not generate the text.";
}

export class OpenCodeTextGenerationEmptyOutputError extends Schema.TaggedError<OpenCodeTextGenerationEmptyOutputError>()(
  "OpenCodeTextGenerationEmptyOutputError",
  {
    ...openCodePromptErrorContext,
    responsePartCount: NonNegativeInt,
    textPartCount: NonNegativeInt,
  },
) {
  override get message(): string {
    return `OpenCode returned empty output for ${this.operation} in ${this.cwd} using ${this.providerId}/${this.modelId} (session ${this.sessionId}, ${this.responsePartCount} response parts, ${this.textPartCount} text parts).`;
  }
}

interface OpenCodePromptFailure {
  readonly name?: string;
  readonly statusCode?: number;
}

interface OpenCodeTextPart {
  readonly type: "text";
  readonly text: string;
}

function getOpenCodePromptFailure(error: unknown): OpenCodePromptFailure | null {
  if (!error || typeof error !== "object") {
    return null;
  }

  const name =
    "name" in error && typeof error.name === "string" && error.name.trim().length > 0
      ? error.name.trim()
      : undefined;
  const data = "data" in error && error.data && typeof error.data === "object" ? error.data : {};
  const statusCode =
    "statusCode" in data && typeof data.statusCode === "number" && Number.isInteger(data.statusCode)
      ? data.statusCode
      : undefined;
  const hasMessage =
    "message" in data && typeof data.message === "string" && data.message.trim().length > 0;
  if (!name && statusCode === undefined && !hasMessage) {
    return null;
  }

  return {
    ...(name ? { name } : {}),
    ...(statusCode !== undefined ? { statusCode } : {}),
  };
}

function isOpenCodeTextPart(part: unknown): part is OpenCodeTextPart {
  return (
    part !== null &&
    typeof part === "object" &&
    "type" in part &&
    part.type === "text" &&
    "text" in part &&
    typeof part.text === "string"
  );
}

function getOpenCodeTextResponse(parts: ReadonlyArray<unknown> | undefined): string {
  return (parts ?? [])
    .filter(isOpenCodeTextPart)
    .map((part) => part.text)
    .join("")
    .trim();
}

export const makeOpenCodeTextGeneration = Effect.fn("makeOpenCodeTextGeneration")(function* (
  openCodeSettings: OpenCodeSettings,
) {
  const host = yield* ProviderHost.ProviderHost;
  const openCodeRuntime = yield* OpenCodeRuntime.OpenCodeRuntime;
  const serverOwner = yield* OpenCodeServerOwner.OpenCodeServerOwner;

  const runOpenCodeJson = Effect.fn("runOpenCodeJson")(function* <S extends Schema.Top>(
    input: TextGenerationOperations.Request<S>,
  ) {
    const parsedModel = OpenCodeRuntime.parseOpenCodeModelSlug(input.modelSelection.model);
    if (!parsedModel) {
      return yield* new TextGenerationError({
        operation: input.operation,
        detail: "OpenCode model selection must use the 'provider/model' format.",
      });
    }

    const fileParts = OpenCodeRuntime.toOpenCodeFileParts({
      attachments: input.attachments?.filter((attachment) => attachment.type === "image"),
      resolveAttachmentPath: host.resolveAttachmentPath,
    });

    const runAgainstServer = Effect.fn("runOpenCodeJson.runAgainstServer")(
      function* (
        server: Pick<
          OpenCodeRuntime.OpenCodeServerConnection,
          "url" | "serverPassword" | "version"
        >,
      ) {
        const client = openCodeRuntime.createOpenCodeSdkClient({
          baseUrl: server.url,
          directory: input.cwd,
          ...(server.serverPassword !== undefined ? { serverPassword: server.serverPassword } : {}),
        });
        const session = yield* Effect.tryPromise({
          try: (signal) =>
            client.session.create(
              {
                title: `T3 Code ${input.operation}`,
                // OpenCode Zen refuses free-model requests that carry no tools, so keep read.
                permission: [
                  { permission: "*", pattern: "*", action: "deny" },
                  { permission: "read", pattern: "*", action: "allow" },
                ],
              },
              { signal },
            ),
          catch: (cause) =>
            new OpenCodeTextGenerationSessionRequestError({
              operation: input.operation,
              cwd: input.cwd,
              cause,
            }),
        });
        if (!session.data) {
          return yield* new OpenCodeTextGenerationSessionPayloadError({
            operation: input.operation,
            cwd: input.cwd,
          });
        }
        yield* Effect.addFinalizer(() =>
          OpenCodeRuntime.runOpenCodeSdk("session.delete", (signal) =>
            client.session.delete({ sessionID: session.data.id }, { signal }),
          ).pipe(Effect.timeout("5 seconds"), Effect.ignore({ log: "Warn" })),
        );
        const selectedAgent = getModelSelectionStringOptionValue(input.modelSelection, "agent");
        const selectedVariant = getModelSelectionStringOptionValue(input.modelSelection, "variant");
        const promptContext = {
          operation: input.operation,
          cwd: input.cwd,
          sessionId: session.data.id,
          providerId: parsedModel.providerID,
          modelId: parsedModel.modelID,
        };

        const result = yield* Effect.tryPromise({
          try: (signal) =>
            client.session.prompt(
              {
                sessionID: session.data.id,
                model: parsedModel,
                ...(selectedAgent ? { agent: selectedAgent } : {}),
                ...(selectedVariant ? { variant: selectedVariant } : {}),
                parts: [{ type: "text", text: input.prompt }, ...fileParts],
              },
              { signal },
            ),
          catch: (cause) =>
            new OpenCodeTextGenerationPromptRequestError({
              ...promptContext,
              cause,
            }),
        }).pipe(
          // Disconnecting the HTTP request does not stop work in a shared or external server.
          Effect.onInterrupt(() =>
            OpenCodeRuntime.runOpenCodeSdk("session.abort", (signal) =>
              client.session.abort({ sessionID: session.data.id }, { signal }),
            ).pipe(
              Effect.interruptible,
              Effect.timeout("10 seconds"),
              Effect.catch(() =>
                Effect.logWarning(
                  "Failed to stop cancelled OpenCode text generation.",
                  promptContext,
                ),
              ),
              Effect.asVoid,
            ),
          ),
        );
        const promptError = result.data?.info?.error;
        const promptFailure = getOpenCodePromptFailure(promptError);
        if (promptFailure) {
          return yield* new OpenCodeTextGenerationPromptResponseError({
            ...promptContext,
            ...(promptFailure.name ? { providerErrorName: promptFailure.name } : {}),
            ...(promptFailure.statusCode !== undefined
              ? { statusCode: promptFailure.statusCode }
              : {}),
            cause: promptError,
          });
        }
        const responseParts = result.data?.parts ?? [];
        const rawText = getOpenCodeTextResponse(responseParts);
        if (rawText.length === 0) {
          return yield* new OpenCodeTextGenerationEmptyOutputError({
            ...promptContext,
            responsePartCount: responseParts.length,
            textPartCount: responseParts.filter(isOpenCodeTextPart).length,
          });
        }
        return rawText;
      },
      Effect.scoped,
      Effect.catchTags({
        OpenCodeTextGenerationSessionRequestError: (cause) =>
          Effect.fail(
            new TextGenerationError({
              operation: cause.operation,
              detail: "OpenCode session.create request failed.",
              cause,
            }),
          ),
        OpenCodeTextGenerationSessionPayloadError: (cause) =>
          Effect.fail(
            new TextGenerationError({
              operation: cause.operation,
              detail: "OpenCode session.create returned no session payload.",
              cause,
            }),
          ),
        OpenCodeTextGenerationPromptRequestError: (cause) =>
          Effect.fail(
            new TextGenerationError({
              operation: cause.operation,
              detail: "OpenCode session.prompt request failed.",
              cause,
            }),
          ),
        OpenCodeTextGenerationPromptResponseError: (cause) =>
          Effect.fail(
            new TextGenerationError({
              operation: cause.operation,
              detail: openCodePromptResponseErrorDetail(cause),
              cause,
            }),
          ),
        OpenCodeTextGenerationEmptyOutputError: (cause) =>
          Effect.fail(
            new TextGenerationError({
              operation: cause.operation,
              detail: "OpenCode returned empty output.",
              cause,
            }),
          ),
      }),
    );

    const serverOutput =
      openCodeSettings.serverUrl.length > 0
        ? openCodeRuntime
            .connectToOpenCodeServer({
              binaryPath: openCodeSettings.binaryPath,
              directory: input.cwd,
              serverUrl: openCodeSettings.serverUrl,
              ...(settingsSecretLiteral(openCodeSettings.serverPassword)
                ? { serverPassword: settingsSecretLiteral(openCodeSettings.serverPassword) }
                : {}),
            })
            .pipe(Effect.flatMap(runAgainstServer), Effect.scoped)
        : serverOwner.withServer(runAgainstServer);
    const rawOutput = yield* serverOutput.pipe(
      Effect.timeoutOrElse({
        duration: GENERATION_TIMEOUT,
        orElse: () =>
          Effect.fail(
            new TextGenerationError({
              operation: input.operation,
              detail: "OpenCode did not finish generating in time.",
            }),
          ),
      }),
      Effect.catchTags({
        OpenCodeRuntimeError: (cause) =>
          Effect.fail(
            new TextGenerationError({
              operation: input.operation,
              detail: OpenCodeRuntime.openCodeRuntimeErrorDetail(cause),
              cause,
            }),
          ),
      }),
    );

    return yield* TextGenerationOperations.decodeJsonReply(input, "OpenCode", rawOutput);
  });

  return TextGenerationOperations.fromRunner(
    "OpenCodeTextGeneration",
    TextGenerationOperations.withoutInvestigation("OpenCode", runOpenCodeJson),
  );
});