import { makeProviderFailure } from "@t3tools/provider-core/server/failure";
import {
XAiPromptFailureText,
isXAiTaskCompletedWakeNotification,
xAiRateLimitedErrorCode,
} from "./xaiAcpExtension.ts";
import { discoverGrokSkills, leadingGrokSkillMention } from "./skills.ts";
import * as HostProcess from "@t3tools/shared/HostProcess";
import { resolveSelfInvocation, type SelfInvocation } from "@t3tools/shared/nodeRuntime";
import {
defaultInstanceIdForDriver,
ProviderDriverKind,
type OrchestrationV2ProviderCapabilities,
type RuntimeMode,
} from "@t3tools/contracts";
import { GrokSettings } from "../settings.ts";
import * as SecureRandom from "effect/crypto/SecureRandom";
import * as Effect from "effect/Effect";
import * as FileSystem from "effect/FileSystem";
import * as Path from "effect/Path";
import * as Schema from "effect/Schema";
import type * as Scope from "effect/Scope";
import * as ChildProcessSpawner from "effect/process/ChildProcessSpawner";
import * as EffectAcpErrors from "effect-acp/errors";
import * as McpProviderSessions from "@t3tools/provider-core/server/McpProviderSessions";
import * as ProviderHost from "@t3tools/provider-core/server/ProviderHost";
import { makeAcpNativeLoggerFactory } from "@t3tools/provider-acp/server/nativeLogging";
import {
applyGrokAcpModelSelection,
currentGrokModelIdFromSessionSetup,
grokApprovalOptions,
makeGrokAcpRuntime,
resolveGrokAcpBaseModelId,
} from "./acpSupport.ts";
import {
extractGrokPlanMarkdownFromToolCallData,
extractXAiAcpBackgroundToolMutation,
extractXAiAcpSubagentEndNotice,
extractXAiAcpSubagentUpdate,
extractXAiAskUserQuestionIdentity,
extractXAiAskUserQuestions,
extractXAiBackgroundTaskCompletion,
extractXAiKilledBackgroundTasks,
extractXAiMonitorTaskId,
xAiBackgroundShellTaskId,
isXAiPersistentMonitor,
extractXAiExitPlanMarkdown,
registerXAiSubagentFinished,
makeXAiAskUserQuestionCancelledResponse,
makeXAiAskUserQuestionResponse,
makeXAiExitPlanModeCapturedResponse,
normalizeXAiAcpToolCallState,
registerXAiBackgroundTaskTracking,
XAiAskUserQuestionRequest,
XAiExitPlanModeRequest,
} from "./xaiAcpExtension.ts";
import { mergeProviderInstanceEnvironment } from "@t3tools/provider-core/server/instanceEnvironment";
import { acpPermissionDisposition } from "@t3tools/provider-acp/server/clientPolicy";
import {
findModelConfigOption,
sessionModelStateFromInitialize,
} from "@t3tools/provider-acp/server/runtimeModel";
import * as AcpSessionRuntime from "@t3tools/provider-acp/server/AcpSessionRuntime";
import * as ProviderEventLoggers from "@t3tools/provider-core/server/ProviderEventLoggers";
import * as IdAllocator from "@t3tools/provider-core/server/IdAllocator";
import * as ProviderContinuationRequests from "@t3tools/provider-core/server/ProviderContinuationRequests";
import * as ProviderAdapter from "@t3tools/provider-core/server/ProviderAdapter";
import {
ProviderAdapterDriverCreateError,
type ProviderAdapterDriver,
type ProviderAdapterDriverCreateInput,
} from "@t3tools/provider-core/server/adapterDriver";
import {
AcpProviderCapabilitiesV2,
makeAcpAdapterV2,
type AcpAdapterV2ExtensionContext,
type AcpAdapterV2Flavor,
type AcpAdapterV2RuntimeInput,
} from "@t3tools/provider-acp/server/adapter";
const isXAiPromptFailureText = Schema.is(XAiPromptFailureText);
export const GROK_PROVIDER = ProviderDriverKind.make("grok");
const GROK_DRIVER_KIND = GROK_PROVIDER;
export const GROK_DEFAULT_INSTANCE_ID = defaultInstanceIdForDriver(GROK_DRIVER_KIND);
const DEFAULT_GROK_SETTINGS = Schema.decodeSync(GrokSettings)({});
const isAcpRequestError = Schema.is(EffectAcpErrors.AcpRequestError);
const GrokProviderCapabilitiesV2 = {
...AcpProviderCapabilitiesV2,
sessions: {
...AcpProviderCapabilitiesV2.sessions,
supportsModelSwitchInSession: true,
supportsRuntimeModeSwitchInSession: false,
},
threads: {
...AcpProviderCapabilitiesV2.threads,
canReadThreadSnapshot: true,
canForkThread: false,
canForkFromTurn: false,
},
subagents: {
...AcpProviderCapabilitiesV2.subagents,
supportsSubagents: true,
exposesSubagentThreadIds: true,
emitsSubagentLifecycle: true,
},
tools: {
...AcpProviderCapabilitiesV2.tools,
supportsMcpTools: true,
},
checkpointing: {
...AcpProviderCapabilitiesV2.checkpointing,
providerCanReadConversationSnapshot: true,
},
} satisfies OrchestrationV2ProviderCapabilities;
export interface GrokAdapterV2Options {
readonly instanceId: Parameters<typeof makeAcpAdapterV2>[0]["instanceId"];
readonly settings: GrokSettings;
readonly environment: NodeJS.ProcessEnv;
readonly hostPlatform: NodeJS.Platform;
readonly selfInvocation: SelfInvocation;
readonly nativeLogging?: Parameters<typeof makeAcpAdapterV2>[0]["nativeLogging"];
readonly continuationRequests?: Parameters<typeof makeAcpAdapterV2>[0]["continuationRequests"];
readonly testHooks?: Parameters<typeof makeAcpAdapterV2>[0]["testHooks"];
readonly makeRuntime?: (
input: AcpAdapterV2RuntimeInput,
) => Effect.Effect<
AcpSessionRuntime.AcpSessionRuntime["Service"],
EffectAcpErrors.AcpError,
ChildProcessSpawner.ChildProcessSpawner | SecureRandom.SecureRandom | Scope.Scope
>;
readonly assertComplete?: Effect.Effect<void, EffectAcpErrors.AcpError>;
}
const registerGrokAcpExtensions: NonNullable<AcpAdapterV2Flavor["registerExtensions"]> = ({
runtime,
requestUserInput,
applyBackgroundTaskMutation,
finishSubagent,
captureProposedPlan,
lastProposedPlanMarkdown,
}) =>
registerXAiBackgroundTaskTracking(runtime, applyBackgroundTaskMutation).pipe(
Effect.andThen(registerXAiSubagentFinished(runtime, finishSubagent)),
Effect.andThen(registerGrokAskUserQuestionExtensions({ runtime, requestUserInput })),
Effect.andThen(
registerGrokExitPlanModeExtensions({
runtime,
captureProposedPlan,
lastProposedPlanMarkdown,
}),
),
);
// Capture the reverse-requested plan, then abandon the native gate to finish the turn.
const registerGrokExitPlanModeExtensions = ({
runtime,
captureProposedPlan,
lastProposedPlanMarkdown,
}: Pick<
AcpAdapterV2ExtensionContext,
"runtime" | "captureProposedPlan" | "lastProposedPlanMarkdown"
>) =>
Effect.forEach(
["x.ai/exit_plan_mode", "_x.ai/exit_plan_mode"] as const,
(method) =>
runtime.handleExtRequest(method, XAiExitPlanModeRequest, (params) =>
Effect.gen(function* () {
const fallback = yield* lastProposedPlanMarkdown;
yield* captureProposedPlan({
planMarkdown: extractXAiExitPlanMarkdown(params, fallback),
});
return makeXAiExitPlanModeCapturedResponse();
}),
),
{ discard: true },
);
const registerGrokAskUserQuestionExtensions = ({
runtime,
requestUserInput,
}: Pick<AcpAdapterV2ExtensionContext, "runtime" | "requestUserInput">) =>
Effect.forEach(
["x.ai/ask_user_question", "_x.ai/ask_user_question"] as const,
(method) =>
runtime.handleExtRequest(method, XAiAskUserQuestionRequest, (params, requestContext) => {
const identity = extractXAiAskUserQuestionIdentity(params);
const questions = extractXAiAskUserQuestions(params).map((question) => ({
...question,
options: [...question.options],
}));
return requestUserInput(
{
nativeItemId: `${identity.sessionId}:xai-question:${identity.toolCallId}`,
nativeRequestId: identity.toolCallId,
questions,
},
requestContext,
).pipe(
Effect.flatMap(({ acknowledgeNativeResponse, answers }) =>
Effect.succeed(
answers === null
? makeXAiAskUserQuestionCancelledResponse()
: makeXAiAskUserQuestionResponse(params, answers),
).pipe(Effect.tap(() => acknowledgeNativeResponse)),
),
);
}),
{ discard: true },
);
/** Explicit policy overrides launch in ask mode so Grok cannot bypass T3 approval checks. */
export function grokLaunchRuntimeMode(
runtimePolicy: ProviderAdapter.ProviderAdapterV2RuntimePolicy,
): RuntimeMode {
return runtimePolicy.approvalPolicy === undefined && runtimePolicy.sandboxPolicy === undefined
? runtimePolicy.runtimeMode
: "approval-required";
}
export function makeGrokAcpAdapterFlavor(
options: GrokAdapterV2Options,
homeDirectory: string,
): AcpAdapterV2Flavor {
return {
driver: GROK_PROVIDER,
runtimeHarness: "Grok",
capabilities: GrokProviderCapabilitiesV2,
interruptPromptOnCancel: false,
// User Stop restarts the process group; steering cancels softly to preserve background work.
restartRuntimeAfterInterrupt: true,
terminateRuntimeProcessGroupOnInterrupt: true,
// Settled Grok sessions accept concurrent prompts; skip cancel to preserve background subagents.
preserveRuntimeOnSettledInterrupt: true,
// Grok accepts image blocks despite advertising promptCapabilities.image:false.
supportsImagePrompts: true,
supportsCompaction: true,
// Grok expands only a leading `/name`, while the `
packages/provider-grok/src/server/adapter.ts at main · sailfork/t3code-github · Sailfork
picker inserts `$name` from the
// `grok inspect` catalog. Ask that catalog again so other `
packages/provider-grok/src/server/adapter.ts at main · sailfork/t3code-github · Sailfork
packages/provider-grok/src/server/adapter.ts at main · sailfork/t3code-github · Sailfork
picker inserts `$name` from the\n // `grok inspect` catalog. Ask that catalog again so other `
packages/provider-grok/src/server/adapter.ts at main · sailfork/t3code-github · Sailfork