import { McpAttachmentInput } from "../attachment/input.ts";
import {
NonNegativeInt,
ModelSelection,
TrimmedNonEmptyString,
ThreadId,
RunId,
OrchestrationV2DelegatedFrom,
OrchestrationV2RunStatus,
OrchestrationV2ThreadLaunchWorkspaceStrategy,
RuntimeMode,
ProviderInteractionMode,
Project,
ProjectCreatePayload,
ProjectUpdatePayload,
ProjectId,
OrchestratorMcpClientRequestId,
OrchestratorMcpEnvironmentTarget,
OrchestratorMcpFailure,
SourceControlCloneRepositoryInput,
SourceControlCloneRepositoryResult,
} from "@t3tools/contracts";
import * as FileSystem from "effect/FileSystem";
import * as DocumentText from "../../../provider/DocumentText.ts";
import * as ServerConfig from "../../../config.ts";
import * as ProviderRegistry from "../../../provider/ProviderRegistry.ts";
import * as ServerSettings from "../../../serverSettings.ts";
import * as ThreadLaunchService from "../../../orchestration-v2/ThreadLaunchService.ts";
import * as Digest from "effect/crypto/Digest";
import * as SecureRandom from "effect/crypto/SecureRandom";
import * as Schema from "effect/Schema";
import { Tool, Toolkit } from "effect/ai";
import * as ProjectService from "../../../project/ProjectService.ts";
import * as ProjectCloneTracker from "../../../project/ProjectCloneTracker.ts";
import * as ManagedProjectFolders from "../../../project/ManagedProjectFolders.ts";
import * as ThreadManagementService from "../../../orchestration-v2/ThreadManagementService.ts";
import * as SourceControlRepositoryService from "../../../sourceControl/SourceControlRepositoryService.ts";
import * as GitVcsDriver from "../../../vcs/GitVcsDriver.ts";
import * as McpInvocationContext from "../../McpInvocationContext.ts";
const shared = {
success: Project,
failure: OrchestratorMcpFailure,
failureMode: "return" as const,
dependencies: [
McpInvocationContext.McpInvocationContext,
ThreadManagementService.ThreadManagementService,
ProjectService.ProjectService,
SecureRandom.SecureRandom,
],
};
const ProjectListTool = Tool.make("t3_project_list", {
...shared,
description: "List projects. Pages can shift.",
parameters: Schema.Struct({
environmentId: OrchestratorMcpEnvironmentTarget,
cursor: Schema.optional(NonNegativeInt),
limit: Schema.optional(Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 100 }))),
}),
success: Schema.Struct({
projects: Schema.Array(Project),
nextCursor: Schema.NullOr(NonNegativeInt),
}),
})
.annotate(Tool.Readonly, true)
.annotate(Tool.Destructive, false);
const ProjectReadTool = Tool.make("t3_project_read", {
...shared,
description: "Read one project: workspace and saved scripts.",
parameters: Schema.Struct({
environmentId: OrchestratorMcpEnvironmentTarget,
projectId: ProjectId,
}),
})
.annotate(Tool.Readonly, true)
.annotate(Tool.Destructive, false);
const ProjectCreateTool = Tool.make("t3_project_create", {
...shared,
description:
"Register a project folder. `createWorkspaceRootIfMissing` creates it; a registered folder is rejected. No `workspaceRoot`: makes a git repo from `title` with README, icon, first commit (`commitError` on failure; project still exists). Clone first with `t3_project_clone` if needed.",
parameters: Schema.Struct({
environmentId: OrchestratorMcpEnvironmentTarget,
...ProjectCreatePayload.fields,
workspaceRoot: Schema.optional(ProjectCreatePayload.fields.workspaceRoot),
}),
success: Schema.Struct({ ...Project.fields, commitError: Schema.optional(Schema.String) }),
dependencies: [...shared.dependencies, ManagedProjectFolders.ManagedProjectFolders],
}).annotate(Tool.Destructive, true);
const ProjectUpdateTool = Tool.make("t3_project_update", {
...shared,
description: "Update one project's settings. Omitted fields are unchanged.",
parameters: Schema.Struct({
environmentId: OrchestratorMcpEnvironmentTarget,
projectId: ProjectId,
...ProjectUpdatePayload.fields,
}),
}).annotate(Tool.Destructive, true);
const ProjectDeleteTool = Tool.make("t3_project_delete", {
...shared,
description: "Delete one project. Nonempty needs `force: true`. Folder on disk stays.",
parameters: Schema.Struct({
environmentId: OrchestratorMcpEnvironmentTarget,
projectId: ProjectId,
force: Schema.optionalKey(Schema.Boolean),
}),
dependencies: [...shared.dependencies, ProjectCloneTracker.ProjectCloneTracker],
}).annotate(Tool.Destructive, true);
const ProjectCloneTool = Tool.make("t3_project_clone", {
...shared,
description:
"Clone a repository (`destinationPath` new or empty). Register after with `t3_project_create`, with the same `environmentId`.",
parameters: Schema.Struct({
environmentId: OrchestratorMcpEnvironmentTarget,
...SourceControlCloneRepositoryInput.fields,
}),
success: SourceControlCloneRepositoryResult,
dependencies: [
...shared.dependencies,
SourceControlRepositoryService.SourceControlRepositoryService,
],
})
.annotate(Tool.Destructive, true)
.annotate(Tool.OpenWorld, true);
const ThreadLaunchTool = Tool.make("t3_thread_launch", {
...shared,
description:
"Create one new top-level thread, bound to its workspace before the agent starts. Task in `message`. Omit `projectId`, model and modes to inherit yours (outside a thread, pass `projectId` or `scratch`); modes cannot exceed yours. After an error or lost reply, retry with the same `clientRequestId`. Follow it with `t3_thread_read` or `t3_thread_wait`. Mention it with its `link`.",
parameters: Schema.Struct({
environmentId: OrchestratorMcpEnvironmentTarget,
projectId: Schema.optional(ProjectId),
scratch: Schema.optional(
Schema.Boolean.annotate({
description:
"No project: a new Scratch folder. Not with `projectId` or `workspaceStrategy`.",
}),
),
title: TrimmedNonEmptyString,
modelSelection: Schema.optional(ModelSelection),
runtimeMode: Schema.optional(RuntimeMode),
interactionMode: Schema.optional(ProviderInteractionMode),
workspaceStrategy: Schema.optional(
OrchestrationV2ThreadLaunchWorkspaceStrategy.annotate({
description:
"'worktree': new checkout from `baseRef`. Honor a requested base. Otherwise, independent work uses the default branch as `remote/branch` (e.g. `origin/main`) with `startFromOrigin: true`; with no remote, use the local default branch. Required unpublished commits and dependent or stacked work use their local base with `startFromOrigin: false`. 'existing_worktree': bind `worktreePath`, a project worktree. 'root': project checkout, the default, not your worktree. Uncommitted edits are not copied.",
}),
),
message: Schema.optional(
Schema.String.check(Schema.isMaxLength(120000)).annotate({
description: "First prompt. Omit it and `attachments` for idle.",
}),
),
attachments: Schema.optional(Schema.Array(McpAttachmentInput).check(Schema.isMaxLength(8))),
clientRequestId: Schema.optional(OrchestratorMcpClientRequestId),
/** Set by a linked environment launching its agent's delegated task here; ignored otherwise. */
delegatedFrom: Schema.optional(OrchestrationV2DelegatedFrom),
}),
success: Schema.Struct({
threadId: ThreadId,
link: Schema.optional(Schema.String),
projectId: ProjectId,
modelSelection: ModelSelection,
runId: Schema.NullOr(RunId),
status: Schema.NullOr(OrchestrationV2RunStatus),
}),
dependencies: [
...shared.dependencies,
ThreadLaunchService.ThreadLaunchService,
ManagedProjectFolders.ManagedProjectFolders,
GitVcsDriver.GitVcsDriver,
FileSystem.FileSystem,
ServerConfig.ServerConfig,
ServerSettings.ServerSettingsService,
ProviderRegistry.ProviderRegistry,
DocumentText.DocumentText,
Digest.Digest,
],
})
.annotate(Tool.Destructive, true)
.annotate(Tool.OpenWorld, true);
export const ProjectToolkit = Toolkit.make(
ThreadLaunchTool,
ProjectListTool,
ProjectReadTool,
ProjectCreateTool,
ProjectUpdateTool,
ProjectDeleteTool,
ProjectCloneTool,
);