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 Schema from "effect/Schema";
import { NonNegativeInt, ThreadId, TrimmedNonEmptyString } from "./baseSchemas.ts";
import {
PROVIDER_SEND_TURN_MAX_FILE_BYTES,
PROVIDER_SEND_TURN_MAX_IMAGE_BYTES,
PROVIDER_SEND_TURN_SUPPORTED_FILE_MIME_TYPES,
PROVIDER_SEND_TURN_SUPPORTED_IMAGE_MIME_TYPES,
} from "./orchestration/attachments.ts";
const ASSET_PATH_MAX_LENGTH = 1024;
export const AssetResource = Schema.Union([
Schema.TaggedStruct("workspace-file", {
threadId: ThreadId,
path: TrimmedNonEmptyString.check(Schema.isMaxLength(ASSET_PATH_MAX_LENGTH)),
}),
Schema.TaggedStruct("attachment", {
attachmentId: TrimmedNonEmptyString.check(Schema.isMaxLength(256)),
}),
]);
export type AssetResource = typeof AssetResource.Type;
export const AssetCreateUrlInput = Schema.Struct({
resource: AssetResource,
});
export type AssetCreateUrlInput = typeof AssetCreateUrlInput.Type;
export const AssetImageDimensions = Schema.Struct({
width: NonNegativeInt.check(Schema.isGreaterThanOrEqualTo(1)),
height: NonNegativeInt.check(Schema.isGreaterThanOrEqualTo(1)),
});
export type AssetImageDimensions = typeof AssetImageDimensions.Type;
export const AssetCreateUrlResult = Schema.Struct({
relativeUrl: TrimmedNonEmptyString.check(Schema.isMaxLength(4096)),
expiresAt: Schema.Number,
sourcePath: Schema.optional(
TrimmedNonEmptyString.check(Schema.isMaxLength(ASSET_PATH_MAX_LENGTH)),
),
/** Pixel size read from the image header, so a client can reserve the exact box before the bytes arrive. */
imageDimensions: Schema.optional(AssetImageDimensions),
});
export type AssetCreateUrlResult = typeof AssetCreateUrlResult.Type;
export const ATTACHMENT_UPLOAD_URL_TTL_MS = 10 * 60_000;
export const AttachmentCreateUploadUrlInput = Schema.Struct({
name: TrimmedNonEmptyString.check(Schema.isMaxLength(255)),
mimeType: Schema.Literals([
...PROVIDER_SEND_TURN_SUPPORTED_IMAGE_MIME_TYPES,
...PROVIDER_SEND_TURN_SUPPORTED_FILE_MIME_TYPES,
]),
sizeBytes: NonNegativeInt.check(
Schema.isGreaterThanOrEqualTo(1),
Schema.isLessThanOrEqualTo(
Math.max(PROVIDER_SEND_TURN_MAX_IMAGE_BYTES, PROVIDER_SEND_TURN_MAX_FILE_BYTES),
),
),
});
export type AttachmentCreateUploadUrlInput = typeof AttachmentCreateUploadUrlInput.Type;
export const AttachmentCreateUploadUrlResult = Schema.Struct({
attachmentId: TrimmedNonEmptyString.check(Schema.isMaxLength(256)),
relativeUrl: TrimmedNonEmptyString.check(Schema.isMaxLength(4096)),
expiresAt: Schema.Number,
});
export type AttachmentCreateUploadUrlResult = typeof AttachmentCreateUploadUrlResult.Type;
export const AttachmentDeleteInput = Schema.Struct({
attachmentId: TrimmedNonEmptyString.check(Schema.isMaxLength(256)),
});
export type AttachmentDeleteInput = typeof AttachmentDeleteInput.Type;
/** Reveals a stored chat attachment in the environment's file manager. */
export const AttachmentRevealInput = Schema.Struct({
attachmentId: TrimmedNonEmptyString.check(Schema.isMaxLength(256)),
});
export type AttachmentRevealInput = typeof AttachmentRevealInput.Type;
export class AttachmentNotFoundError extends Schema.TaggedErrorClass<AttachmentNotFoundError>()(
"AttachmentNotFoundError",
{
attachmentId: TrimmedNonEmptyString,
},
) {
override get message(): string {
return "The attachment is no longer stored on this environment.";
}
}
export class AttachmentUploadSigningKeyError extends Schema.TaggedErrorClass<AttachmentUploadSigningKeyError>()(
"AttachmentUploadSigningKeyError",
{
cause: Schema.Defect(),
},
) {
override get message(): string {
return "Failed to load the attachment upload signing key.";
}
}
export class AssetWorkspaceContextNotFoundError extends Schema.TaggedErrorClass<AssetWorkspaceContextNotFoundError>()(
"AssetWorkspaceContextNotFoundError",
{
resource: AssetResource,
},
) {
override get message(): string {
return "Workspace context was not found.";
}
}
export class AssetWorkspaceContextResolutionError extends Schema.TaggedErrorClass<AssetWorkspaceContextResolutionError>()(
"AssetWorkspaceContextResolutionError",
{
resource: AssetResource,
cause: Schema.Defect(),
},
) {
override get message(): string {
return "Failed to resolve workspace context.";
}
}
export class AssetWorkspaceRootNormalizationError extends Schema.TaggedErrorClass<AssetWorkspaceRootNormalizationError>()(
"AssetWorkspaceRootNormalizationError",
{
resource: AssetResource,
cause: Schema.Defect(),
},
) {
override get message(): string {
return "Failed to normalize the workspace root.";
}
}
export class AssetWorkspacePathValidationError extends Schema.TaggedErrorClass<AssetWorkspacePathValidationError>()(
"AssetWorkspacePathValidationError",
{
resource: AssetResource,
cause: Schema.Defect(),
},
) {
override get message(): string {
return "Workspace file path must be relative to the project root.";
}
}
export class AssetPreviewTypeValidationError extends Schema.TaggedErrorClass<AssetPreviewTypeValidationError>()(
"AssetPreviewTypeValidationError",
{
resource: AssetResource,
},
) {
override get message(): string {
return "Only browser documents and images can be previewed.";
}
}
export class AssetWorkspaceAssetInspectionError extends Schema.TaggedErrorClass<AssetWorkspaceAssetInspectionError>()(
"AssetWorkspaceAssetInspectionError",
{
resource: AssetResource,
cause: Schema.Defect(),
},
) {
override get message(): string {
return "Failed to inspect the workspace asset.";
}
}
export class AssetWorkspaceAssetNotFoundError extends Schema.TaggedErrorClass<AssetWorkspaceAssetNotFoundError>()(
"AssetWorkspaceAssetNotFoundError",
{
resource: AssetResource,
},
) {
override get message(): string {
return "Workspace asset was not found.";
}
}
export class AssetWorkspaceResolutionError extends Schema.TaggedErrorClass<AssetWorkspaceResolutionError>()(
"AssetWorkspaceResolutionError",
{
resource: AssetResource,
cause: Schema.Defect(),
},
) {
override get message(): string {
return "Failed to resolve workspace.";
}
}
export class AssetAttachmentNotFoundError extends Schema.TaggedErrorClass<AssetAttachmentNotFoundError>()(
"AssetAttachmentNotFoundError",
{
resource: AssetResource,
},
) {
override get message(): string {
return "Attachment was not found.";
}
}
export class AssetSigningKeyLoadError extends Schema.TaggedErrorClass<AssetSigningKeyLoadError>()(
"AssetSigningKeyLoadError",
{
resource: AssetResource,
cause: Schema.Defect(),
},
) {
override get message(): string {
return "Failed to load the asset signing key.";
}
}
export const AssetAccessError = Schema.Union([
AssetWorkspaceContextNotFoundError,
AssetWorkspaceContextResolutionError,
AssetWorkspaceRootNormalizationError,
AssetWorkspacePathValidationError,
AssetPreviewTypeValidationError,
AssetWorkspaceAssetInspectionError,
AssetWorkspaceAssetNotFoundError,
AssetWorkspaceResolutionError,
AssetAttachmentNotFoundError,
AssetSigningKeyLoadError,
]);
export type AssetAccessError = typeof AssetAccessError.Type;