Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.
import * as Predicate from "effect/Predicate";
import * as Schema from "effect/Schema";
import { NonNegativeInt } from "@akeru/contracts";
export const OpenCodeTextGenerationOperation = Schema.Literals([
"generateBranchName",
"generateThreadTitle",
]);
export type OpenCodeTextGenerationOperation = typeof OpenCodeTextGenerationOperation.Type;
export const openCodeTextGenerationErrorContext = {
operation: OpenCodeTextGenerationOperation,
cwd: Schema.String,
};
export class OpenCodeTextGenerationSessionRequestError extends Schema.TaggedErrorClass<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.TaggedErrorClass<OpenCodeTextGenerationSessionPayloadError>()(
"OpenCodeTextGenerationSessionPayloadError",
openCodeTextGenerationErrorContext,
) {
override get message(): string {
return `OpenCode session.create returned no session payload for ${this.operation} in ${this.cwd}.`;
}
}
export const openCodePromptErrorContext = {
...openCodeTextGenerationErrorContext,
sessionId: Schema.String,
providerId: Schema.String,
modelId: Schema.String,
};
export class OpenCodeTextGenerationPromptRequestError extends Schema.TaggedErrorClass<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.TaggedErrorClass<OpenCodeTextGenerationPromptResponseError>()(
"OpenCodeTextGenerationPromptResponseError",
{
...openCodePromptErrorContext,
providerErrorName: Schema.optional(Schema.String),
providerMessage: Schema.String,
},
) {
override get message(): string {
const providerError = this.providerErrorName ? ` ${this.providerErrorName}` : "";
return `OpenCode prompt${providerError} failed for ${this.operation} in ${this.cwd} using ${this.providerId}/${this.modelId} (session ${this.sessionId}): ${this.providerMessage}`;
}
}
export class OpenCodeTextGenerationEmptyOutputError extends Schema.TaggedErrorClass<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).`;
}
}
export interface OpenCodePromptFailure {
readonly name?: string;
readonly message: string;
}
export interface OpenCodeTextPart {
readonly type: "text";
readonly text: string;
}
export function getOpenCodePromptFailure(cause: unknown): OpenCodePromptFailure | null {
if (!cause || !Predicate.isObjectKeyword(cause)) {
return null;
}
const name =
"name" in cause && Predicate.isString(cause.name) && cause.name.trim().length > 0
? cause.name.trim()
: undefined;
const message =
"data" in cause &&
cause.data &&
Predicate.isObjectKeyword(cause.data) &&
"message" in cause.data &&
Predicate.isString(cause.data.message)
? cause.data.message.trim()
: "";
if (message.length > 0) {
return {
...(name ? { name } : {}),
message,
};
}
if (name) {
return { name, message: name };
}
return null;
}
export function isOpenCodeTextPart(part: unknown): part is OpenCodeTextPart {
return (
Predicate.isObjectOrArray(part) &&
"type" in part &&
part.type === "text" &&
"text" in part &&
Predicate.isString(part.text)
);
}
export function getOpenCodeTextResponse(parts: ReadonlyArray<unknown> | undefined): string {
return (parts ?? [])
.filter(isOpenCodeTextPart)
.map((part) => part.text)
.join("")
.trim();
}