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 Match from "effect/Match";
import { readProtocolJson } from "../ProtocolJson.ts";
import * as Predicate from "effect/Predicate";
import { type ProviderApprovalDecision, type ProviderApprovalOption } from "@akeru/contracts";
import * as Schema from "effect/Schema";
import * as EffectCodexSchema from "effect-codex-app-server/schema";
export const NullableMcpElicitationString = Schema.NullOr(Schema.String);
export const McpElicitationMetadata = Schema.Struct({
app: Schema.optionalKey(NullableMcpElicitationString),
app_name: Schema.optionalKey(NullableMcpElicitationString),
appName: Schema.optionalKey(NullableMcpElicitationString),
connector_name: Schema.optionalKey(NullableMcpElicitationString),
connectorName: Schema.optionalKey(NullableMcpElicitationString),
allowPersistentApproval: Schema.optionalKey(Schema.NullOr(Schema.Boolean)),
persist: Schema.optionalKey(
Schema.NullOr(Schema.Union([Schema.String, Schema.Array(Schema.String)])),
),
target: Schema.optionalKey(
Schema.NullOr(
Schema.Struct({
app: Schema.optionalKey(NullableMcpElicitationString),
name: Schema.optionalKey(NullableMcpElicitationString),
}),
),
),
tool_params: Schema.optionalKey(
Schema.NullOr(
Schema.Struct({
app: Schema.optionalKey(NullableMcpElicitationString),
app_name: Schema.optionalKey(NullableMcpElicitationString),
}),
),
),
});
export const McpElicitationFormField = Schema.Struct({
type: Schema.optionalKey(NullableMcpElicitationString),
title: Schema.optionalKey(NullableMcpElicitationString),
description: Schema.optionalKey(NullableMcpElicitationString),
default: Schema.optionalKey(Schema.Unknown),
enum: Schema.optionalKey(Schema.NullOr(Schema.Array(Schema.String))),
enumNames: Schema.optionalKey(Schema.NullOr(Schema.Array(Schema.String))),
oneOf: Schema.optionalKey(
Schema.NullOr(
Schema.Array(
Schema.Struct({
const: Schema.String,
title: Schema.optionalKey(NullableMcpElicitationString),
}),
),
),
),
});
export const McpElicitationForm = Schema.Struct({
properties: Schema.optionalKey(Schema.Record(Schema.String, McpElicitationFormField)),
required: Schema.optionalKey(Schema.NullOr(Schema.Array(Schema.String))),
});
export const isMcpElicitationMetadata = Schema.is(McpElicitationMetadata);
export const isMcpElicitationForm = Schema.is(McpElicitationForm);
export type McpElicitationPersistenceDecision = Extract<
ProviderApprovalDecision,
"acceptForSession" | "acceptAlways"
>;
export function mcpElicitationPersistenceDecision(
value: string,
): McpElicitationPersistenceDecision | null {
const normalized = value.toLowerCase();
if (normalized.includes("session")) return "acceptForSession";
if (
normalized.includes("always") ||
normalized.includes("permanent") ||
normalized.includes("forever") ||
normalized.includes("persistent")
) {
return "acceptAlways";
}
return null;
}
export function mcpElicitationFormFields(
payload: EffectCodexSchema.McpServerElicitationRequestParams,
) {
if (payload.mode === "url" || !isMcpElicitationForm(payload.requestedSchema)) {
return undefined;
}
return payload.requestedSchema;
}
export function mcpElicitationFieldOptions(field: typeof McpElicitationFormField.Type) {
if (field.oneOf) {
return field.oneOf.map((option) => ({ value: option.const, label: option.title }));
}
return (field.enum ?? []).map((value, index) => ({
value,
label: field.enumNames?.[index],
}));
}
export function isMcpElicitationPersistenceField(
key: string,
field: typeof McpElicitationFormField.Type,
): boolean {
return (
mcpElicitationPersistenceDecision(key) !== null ||
key.toLowerCase() === "persist" ||
mcpElicitationPersistenceDecision(field.title ?? "") !== null ||
mcpElicitationPersistenceDecision(field.description ?? "") !== null
);
}
export interface McpElicitationDescription {
readonly appName: string;
readonly options: ReadonlyArray<ProviderApprovalOption>;
}
/** Returns the app and approval choices advertised by an MCP elicitation. */
export function describeMcpElicitation(
payload: EffectCodexSchema.McpServerElicitationRequestParams,
): McpElicitationDescription {
const metadata = isMcpElicitationMetadata(payload._meta) ? payload._meta : undefined;
const appName =
metadata?.app_name ??
metadata?.appName ??
metadata?.app ??
metadata?.target?.app ??
metadata?.target?.name ??
metadata?.tool_params?.app_name ??
metadata?.tool_params?.app ??
payload.message.match(/^Allow ChatGPT to use (.+?)\?$/i)?.[1] ??
metadata?.connector_name ??
metadata?.connectorName ??
payload.serverName;
const persistenceOptions = new Map<McpElicitationPersistenceDecision, string>();
const persist = metadata?.persist;
for (const value of Predicate.isString(persist) ? [persist] : (persist ?? [])) {
const decision = mcpElicitationPersistenceDecision(value);
if (decision) persistenceOptions.set(decision, "");
}
if (metadata?.allowPersistentApproval) {
persistenceOptions.set("acceptAlways", "");
}
const form = mcpElicitationFormFields(payload);
for (const [key, field] of Object.entries(form?.properties ?? {})) {
for (const option of mcpElicitationFieldOptions(field)) {
const decision = mcpElicitationPersistenceDecision(option.value);
if (decision) persistenceOptions.set(decision, option.label ?? "");
}
if (field.type === "boolean" && isMcpElicitationPersistenceField(key, field)) {
persistenceOptions.set("acceptAlways", field.title ?? "");
}
}
return {
appName,
options: [
{ decision: "cancel", label: "Cancel" },
{ decision: "decline", label: "Decline" },
...(persistenceOptions.has("acceptForSession") &&
toMcpElicitationResponse(payload, "acceptForSession").action === "accept"
? [
{
decision: "acceptForSession" as const,
label: persistenceOptions.get("acceptForSession") || "Always allow this session",
},
]
: []),
...(persistenceOptions.has("acceptAlways") &&
toMcpElicitationResponse(payload, "acceptAlways").action === "accept"
? [
{
decision: "acceptAlways" as const,
label: persistenceOptions.get("acceptAlways") || "Always allow",
},
]
: []),
{ decision: "accept", label: "Approve" },
],
};
}
/** Converts a T3 approval decision into the MCP elicitation wire response. */
export function toMcpElicitationResponse(
payload: EffectCodexSchema.McpServerElicitationRequestParams,
decision: ProviderApprovalDecision,
): EffectCodexSchema.McpServerElicitationRequestResponse {
if (decision === "decline" || decision === "cancel") {
return { action: decision };
}
if (payload.mode === "url") {
return { action: "decline" };
}
const persist = Match.value(decision).pipe(
Match.when("acceptForSession", () => "session" as const),
Match.when("acceptAlways", () => "always" as const),
Match.orElse(() => undefined),
);
const form = mcpElicitationFormFields(payload);
const content: Record<string, Schema.Json> = {};
for (const [key, field] of Object.entries(form?.properties ?? {})) {
const options = mcpElicitationFieldOptions(field);
const chosenOption = options.find((option) =>
persist
? mcpElicitationPersistenceDecision(option.value) === decision
: /once|accept|approve|allow/i.test(option.value) &&
mcpElicitationPersistenceDecision(option.value) === null,
);
if (chosenOption) {
content[key] = chosenOption.value;
} else if (field.type === "boolean" && isMcpElicitationPersistenceField(key, field)) {
content[key] = decision === "acceptAlways";
} else if (field.default !== undefined && field.default !== null) {
const defaultValue = readProtocolJson(field.default);
if (defaultValue !== undefined) content[key] = defaultValue;
}
}
if (form?.required?.some((key) => !Object.hasOwn(content, key))) {
return { action: "decline" };
}
return {
action: "accept",
...(persist ? { _meta: { persist } } : {}),
...(form ? { content } : {}),
};
}