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 Effect from "effect/Effect";
import * as Schema from "effect/Schema";
import {
ForwardCompatibleArray,
IsoDateTime,
NonNegativeInt,
TrimmedNonEmptyString,
} from "../baseSchemas.ts";
import { ModelCapabilities } from "../model.ts";
import { ProviderDriverKind, ProviderInstanceId } from "../providerInstance.ts";
const KeybindingsMalformedConfigIssue = Schema.Struct({
kind: Schema.Literal("keybindings.malformed-config"),
message: TrimmedNonEmptyString,
});
const KeybindingsInvalidEntryIssue = Schema.Struct({
kind: Schema.Literal("keybindings.invalid-entry"),
message: TrimmedNonEmptyString,
index: Schema.Number,
});
export const ServerConfigIssue = Schema.Union([
KeybindingsMalformedConfigIssue,
KeybindingsInvalidEntryIssue,
]);
export type ServerConfigIssue = typeof ServerConfigIssue.Type;
// Issue kinds grow over time; older clients must not fail the whole config
// decode over a kind they cannot render.
export const ServerConfigIssues = ForwardCompatibleArray(ServerConfigIssue);
export const ServerProviderState = Schema.Literals(["ready", "warning", "error", "disabled"]);
export type ServerProviderState = typeof ServerProviderState.Type;
export const ServerProviderAuthStatus = Schema.Literals([
"authenticated",
"unauthenticated",
"unknown",
]);
export type ServerProviderAuthStatus = typeof ServerProviderAuthStatus.Type;
export const ServerProviderAuth = Schema.Struct({
status: ServerProviderAuthStatus,
type: Schema.optional(TrimmedNonEmptyString),
label: Schema.optional(TrimmedNonEmptyString),
email: Schema.optional(TrimmedNonEmptyString),
});
export type ServerProviderAuth = typeof ServerProviderAuth.Type;
export const ServerProviderUnavailability = Schema.Literals([
"missing-login",
"expired-login",
"unsupported-model",
"limit-reached",
"usage-cap",
"temporary-failure",
]);
export type ServerProviderUnavailability = typeof ServerProviderUnavailability.Type;
export const ServerProviderModel = Schema.Struct({
slug: TrimmedNonEmptyString,
name: TrimmedNonEmptyString,
shortName: Schema.optional(TrimmedNonEmptyString),
subProvider: Schema.optional(TrimmedNonEmptyString),
isCustom: Schema.Boolean,
isDefault: Schema.optional(Schema.Boolean),
isLegacy: Schema.optional(Schema.Boolean),
capabilities: Schema.NullOr(ModelCapabilities),
});
export type ServerProviderModel = typeof ServerProviderModel.Type;
export const ServerProviderSlashCommandInput = Schema.Struct({
hint: TrimmedNonEmptyString,
});
export type ServerProviderSlashCommandInput = typeof ServerProviderSlashCommandInput.Type;
export const ServerProviderSlashCommand = Schema.Struct({
name: TrimmedNonEmptyString,
description: Schema.optional(TrimmedNonEmptyString),
input: Schema.optional(ServerProviderSlashCommandInput),
});
export type ServerProviderSlashCommand = typeof ServerProviderSlashCommand.Type;
export const ServerProviderSkill = Schema.Struct({
name: TrimmedNonEmptyString,
description: Schema.optional(TrimmedNonEmptyString),
path: TrimmedNonEmptyString,
scope: Schema.optional(TrimmedNonEmptyString),
enabled: Schema.Boolean,
displayName: Schema.optional(TrimmedNonEmptyString),
shortDescription: Schema.optional(TrimmedNonEmptyString),
/**
* Optional per-skill icon reported by the provider: an emoji or a short
* named glyph from skill frontmatter or provider metadata (e.g. the Codex
* app-server's interface icon). Clients fall back to a source-kind glyph
* when absent, so older servers can omit it without breaking decode.
*/
icon: Schema.optional(TrimmedNonEmptyString),
});
export type ServerProviderSkill = typeof ServerProviderSkill.Type;
/**
* Availability of a configured provider instance from the runtime's POV.
*
* - `available` — the build ships this driver and an instance is wired
* up. Default for legacy snapshots produced from the closed
* `ServerSettings.providers` map.
* - `unavailable` — the user's `ServerSettings.providerInstances` (or a
* persisted thread / session binding) references a driver this build
* doesn't ship. Common after rolling back from a fork or PR branch
* that introduced a new driver. The snapshot is preserved so the UI
* can render "missing driver" affordances and so the data round-trips
* when the user moves back to the fork.
*
* Snapshots with `availability: "unavailable"` MUST set
* `installed: false` and `enabled: false`; the runtime refuses turn
* starts against them with a structured error.
*/
export const ServerProviderAvailability = Schema.Literals(["available", "unavailable"]);
export type ServerProviderAvailability = typeof ServerProviderAvailability.Type;
export const ServerProviderContinuation = Schema.Struct({
groupKey: TrimmedNonEmptyString,
});
export type ServerProviderContinuation = typeof ServerProviderContinuation.Type;
export const ServerProviderVersionAdvisoryStatus = Schema.Literals([
"unknown",
"current",
"behind_latest",
]);
export type ServerProviderVersionAdvisoryStatus = typeof ServerProviderVersionAdvisoryStatus.Type;
export const ServerProviderVersionAdvisory = Schema.Struct({
status: ServerProviderVersionAdvisoryStatus,
currentVersion: Schema.NullOr(TrimmedNonEmptyString),
latestVersion: Schema.NullOr(TrimmedNonEmptyString),
updateCommand: Schema.NullOr(TrimmedNonEmptyString),
canUpdate: Schema.Boolean.pipe(Schema.withDecodingDefault(Effect.succeed(false))),
checkedAt: Schema.NullOr(IsoDateTime),
message: Schema.NullOr(TrimmedNonEmptyString),
});
export type ServerProviderVersionAdvisory = typeof ServerProviderVersionAdvisory.Type;
export const ServerProviderUpdateStatus = Schema.Literals([
"idle",
"queued",
"running",
"succeeded",
"failed",
"unchanged",
]);
export type ServerProviderUpdateStatus = typeof ServerProviderUpdateStatus.Type;
export const ServerProviderUpdateState = Schema.Struct({
status: ServerProviderUpdateStatus,
startedAt: Schema.NullOr(IsoDateTime),
finishedAt: Schema.NullOr(IsoDateTime),
message: Schema.NullOr(TrimmedNonEmptyString),
output: Schema.NullOr(Schema.String.check(Schema.isMaxLength(10_000))),
});
export type ServerProviderUpdateState = typeof ServerProviderUpdateState.Type;
export const ServerProvider = Schema.Struct({
// Routing key for the configured instance this snapshot represents. This
// is the only stable identity consumers may use for provider routing.
instanceId: ProviderInstanceId,
// Open driver kind slug that selects the implementation handling this
// instance. It is metadata/capability context, not a routing key.
driver: ProviderDriverKind,
displayName: Schema.optional(TrimmedNonEmptyString),
accentColor: Schema.optional(TrimmedNonEmptyString),
badgeLabel: Schema.optional(TrimmedNonEmptyString),
continuation: Schema.optional(ServerProviderContinuation),
showInteractionModeToggle: Schema.optional(Schema.Boolean),
requiresNewThreadForModelChange: Schema.optional(Schema.Boolean),
enabled: Schema.Boolean,
installed: Schema.Boolean,
version: Schema.NullOr(TrimmedNonEmptyString),
status: ServerProviderState,
auth: ServerProviderAuth,
checkedAt: IsoDateTime,
message: Schema.optional(TrimmedNonEmptyString),
// Optional for back-compat: every legacy producer omits this field and
// an absent value is interpreted as `"available"` by consumers (see
// `isProviderAvailable`). New `ProviderInstanceRegistry` outputs set it
// explicitly so the UI can render unavailable shadows from
// `ServerSettings.providerInstances`.
availability: Schema.optional(ServerProviderAvailability),
// Human-readable reason populated when `availability === "unavailable"`.
// Surfaces in the UI alongside the missing-driver affordance.
unavailableReason: Schema.optional(TrimmedNonEmptyString),
// Knowable turn-start failures are exposed in the provider snapshot so
// clients can explain them before persisting a message.
unavailability: Schema.optional(ServerProviderUnavailability),
unavailabilityDetail: Schema.optional(TrimmedNonEmptyString),
repairAction: Schema.optional(TrimmedNonEmptyString),
models: Schema.Array(ServerProviderModel),
slashCommands: Schema.Array(ServerProviderSlashCommand).pipe(
Schema.withDecodingDefault(Effect.succeed([])),
),
skills: Schema.Array(ServerProviderSkill).pipe(Schema.withDecodingDefault(Effect.succeed([]))),
versionAdvisory: Schema.optionalKey(ServerProviderVersionAdvisory),
updateState: Schema.optionalKey(ServerProviderUpdateState),
});
export type ServerProvider = typeof ServerProvider.Type;
// Provider status kinds grow over time (ServerProviderState,
// ServerProviderAuthStatus, ServerProviderVersionAdvisoryStatus,
// ServerProviderUpdateStatus); an older client must not fail the whole config
// decode over one provider it cannot render.
export const ServerProviders = ForwardCompatibleArray(ServerProvider);
export type ServerProviders = typeof ServerProviders.Type;
/**
* Treat the optional `availability` as "available" when absent. This is
* the rule legacy producers (which omit the field) and new producers
* (which set it explicitly) agree on so consumers never have to thread
* `?? "available"` defaults through their code paths.
*/
export const isProviderAvailable = (snapshot: ServerProvider): boolean =>
snapshot.availability !== "unavailable";
export const ServerObservability = Schema.Struct({
logsDirectoryPath: TrimmedNonEmptyString,
localTracingEnabled: Schema.Boolean,
otlpTracesUrl: Schema.optional(TrimmedNonEmptyString),
otlpTracesEnabled: Schema.Boolean,
otlpMetricsUrl: Schema.optional(TrimmedNonEmptyString),
otlpMetricsEnabled: Schema.Boolean,
});
export type ServerObservability = typeof ServerObservability.Type;
export const ServerTraceDiagnosticsErrorKind = Schema.Literals([
"trace-file-not-found",
"trace-file-read-failed",
]);
export type ServerTraceDiagnosticsErrorKind = typeof ServerTraceDiagnosticsErrorKind.Type;
export const ServerTraceDiagnosticsSpanSummary = Schema.Struct({
name: TrimmedNonEmptyString,
count: NonNegativeInt,
failureCount: NonNegativeInt,
totalDurationMs: Schema.Number,
averageDurationMs: Schema.Number,
maxDurationMs: Schema.Number,
});
export type ServerTraceDiagnosticsSpanSummary = typeof ServerTraceDiagnosticsSpanSummary.Type;
export const ServerTraceDiagnosticsFailureSummary = Schema.Struct({
name: TrimmedNonEmptyString,
cause: TrimmedNonEmptyString,
count: NonNegativeInt,
lastSeenAt: Schema.DateTimeUtc,
traceId: TrimmedNonEmptyString,
spanId: TrimmedNonEmptyString,
});
export type ServerTraceDiagnosticsFailureSummary = typeof ServerTraceDiagnosticsFailureSummary.Type;
export const ServerTraceDiagnosticsRecentFailure = Schema.Struct({
name: TrimmedNonEmptyString,
cause: TrimmedNonEmptyString,
durationMs: Schema.Number,
endedAt: Schema.DateTimeUtc,
traceId: TrimmedNonEmptyString,
spanId: TrimmedNonEmptyString,
});
export type ServerTraceDiagnosticsRecentFailure = typeof ServerTraceDiagnosticsRecentFailure.Type;
export const ServerTraceDiagnosticsSpanOccurrence = Schema.Struct({
name: TrimmedNonEmptyString,
durationMs: Schema.Number,
endedAt: Schema.DateTimeUtc,
traceId: TrimmedNonEmptyString,
spanId: TrimmedNonEmptyString,
});
export type ServerTraceDiagnosticsSpanOccurrence = typeof ServerTraceDiagnosticsSpanOccurrence.Type;
export const ServerTraceDiagnosticsLogEvent = Schema.Struct({
spanName: TrimmedNonEmptyString,
level: TrimmedNonEmptyString,
message: TrimmedNonEmptyString,
seenAt: Schema.DateTimeUtc,
traceId: TrimmedNonEmptyString,
spanId: TrimmedNonEmptyString,
});
export type ServerTraceDiagnosticsLogEvent = typeof ServerTraceDiagnosticsLogEvent.Type;
export const ServerTraceDiagnosticsResult = Schema.Struct({
traceFilePath: TrimmedNonEmptyString,
scannedFilePaths: Schema.Array(TrimmedNonEmptyString),
readAt: Schema.DateTimeUtc,
recordCount: NonNegativeInt,
parseErrorCount: NonNegativeInt,
firstSpanAt: Schema.Option(Schema.DateTimeUtc),
lastSpanAt: Schema.Option(Schema.DateTimeUtc),
failureCount: NonNegativeInt,
interruptionCount: NonNegativeInt,
slowSpanThresholdMs: NonNegativeInt,
slowSpanCount: NonNegativeInt,
logLevelCounts: Schema.Record(TrimmedNonEmptyString, NonNegativeInt),
topSpansByCount: Schema.Array(ServerTraceDiagnosticsSpanSummary),
slowestSpans: Schema.Array(ServerTraceDiagnosticsSpanOccurrence),
commonFailures: Schema.Array(ServerTraceDiagnosticsFailureSummary),
latestFailures: Schema.Array(ServerTraceDiagnosticsRecentFailure),
latestWarningAndErrorLogs: Schema.Array(ServerTraceDiagnosticsLogEvent),
partialFailure: Schema.Option(Schema.Boolean),
error: Schema.Option(
Schema.Struct({
kind: ServerTraceDiagnosticsErrorKind,
message: TrimmedNonEmptyString,
}),
),
});
export type ServerTraceDiagnosticsResult = typeof ServerTraceDiagnosticsResult.Type;