@meistrari/agent-core 0.0.0

package/src/protocol/agent-tool-name.ts

@@ -0,0 +1,48 @@
+/**
+ * The tool vocabulary `agent.tool.call.started.toolName` is guaranteed to speak.
+ * Provider adapters map their own names onto it before the event is emitted, so
+ * every consumer — supervisor, server, web — reads one taxonomy.
+ */
+export const CANONICAL_TOOL = {
+    bash: 'bash',
+    read: 'read',
+    write: 'write',
+    edit: 'edit',
+    webSearch: 'web_search',
+    webFetch: 'web_fetch',
+    glob: 'glob',
+    grep: 'grep',
+    viewImage: 'view_image',
+    imageGeneration: 'image_generation',
+    todoWrite: 'todo_write',
+    task: 'task',
+    taskCreate: 'task_create',
+    taskGet: 'task_get',
+    taskUpdate: 'task_update',
+    taskList: 'task_list',
+} as const
+
+export type AgentCanonicalToolName = typeof CANONICAL_TOOL[keyof typeof CANONICAL_TOOL]
+
+const PROVIDER_TOOL_NAME_ALIASES: Record<string, string> = {
+    Bash: CANONICAL_TOOL.bash,
+    Read: CANONICAL_TOOL.read,
+    Write: CANONICAL_TOOL.write,
+    Edit: CANONICAL_TOOL.edit,
+    MultiEdit: CANONICAL_TOOL.edit,
+    NotebookEdit: CANONICAL_TOOL.edit,
+    WebSearch: CANONICAL_TOOL.webSearch,
+    WebFetch: CANONICAL_TOOL.webFetch,
+    Glob: CANONICAL_TOOL.glob,
+    Grep: CANONICAL_TOOL.grep,
+    Task: CANONICAL_TOOL.task,
+    TaskCreate: CANONICAL_TOOL.taskCreate,
+    TaskGet: CANONICAL_TOOL.taskGet,
+    TaskUpdate: CANONICAL_TOOL.taskUpdate,
+    TaskList: CANONICAL_TOOL.taskList,
+    TodoWrite: CANONICAL_TOOL.todoWrite,
+}
+
+export function canonicalToolName(rawName: string): string {
+    return PROVIDER_TOOL_NAME_ALIASES[rawName] ?? rawName
+}

package/src/protocol/agent-tool.ts

@@ -0,0 +1,40 @@
+import z from 'zod'
+import { jsonObjectSchema, jsonValueSchema } from './agent-json'
+
+export const agentToolDefinitionSchema = z.object({
+    name: z.string().regex(/^[\w-]{1,128}$/),
+    description: z.string().min(1),
+    inputSchema: jsonObjectSchema,
+}).strict()
+
+export const agentToolTextContentSchema = z.object({
+    type: z.literal('text'),
+    text: z.string(),
+}).strict()
+
+export const agentToolImageContentSchema = z.object({
+    type: z.literal('image'),
+    data: z.string().min(1),
+    mimeType: z.string().min(1),
+}).strict()
+
+export const agentToolContentSchema = z.discriminatedUnion('type', [
+    agentToolTextContentSchema,
+    agentToolImageContentSchema,
+])
+
+export const agentToolResultSchema = z.object({
+    success: z.boolean(),
+    content: z.array(agentToolContentSchema),
+}).strict()
+
+export const agentToolCallStatusSchema = z.enum(['completed', 'failed', 'cancelled'])
+
+export const agentToolCallInputSchema = jsonValueSchema
+
+export type AgentToolDefinition = z.infer<typeof agentToolDefinitionSchema>
+export type AgentToolTextContent = z.infer<typeof agentToolTextContentSchema>
+export type AgentToolImageContent = z.infer<typeof agentToolImageContentSchema>
+export type AgentToolContent = z.infer<typeof agentToolContentSchema>
+export type AgentToolResult = z.infer<typeof agentToolResultSchema>
+export type AgentToolCallStatus = z.infer<typeof agentToolCallStatusSchema>

package/src/protocol/agent-usage.ts

@@ -0,0 +1,14 @@
+import z from 'zod'
+
+const tokenCountSchema = z.number().int().nonnegative()
+
+export const agentUsageSchema = z.object({
+    inputTokens: tokenCountSchema.optional(),
+    outputTokens: tokenCountSchema.optional(),
+    cacheReadTokens: tokenCountSchema.optional(),
+    cacheWriteTokens: tokenCountSchema.optional(),
+    reasoningOutputTokens: tokenCountSchema.optional(),
+    totalTokens: tokenCountSchema.optional(),
+}).strict()
+
+export type AgentUsage = z.infer<typeof agentUsageSchema>

package/src/protocol/agent-user-input.ts

@@ -0,0 +1,38 @@
+import z from 'zod'
+import { jsonValueSchema } from './agent-json'
+
+export const agentUserInputOptionSchema = z.object({
+    value: z.string().min(1),
+    label: z.string().min(1),
+    description: z.string().min(1).optional(),
+}).strict()
+
+const agentUserInputQuestionBaseSchema = z.object({
+    id: z.string().min(1),
+    label: z.string().min(1),
+    description: z.string().min(1).optional(),
+    required: z.boolean().optional(),
+}).strict()
+
+export const agentUserInputTextQuestionSchema = agentUserInputQuestionBaseSchema.extend({
+    type: z.literal('text'),
+    placeholder: z.string().min(1).optional(),
+}).strict()
+
+export const agentUserInputSingleSelectQuestionSchema = agentUserInputQuestionBaseSchema.extend({
+    type: z.literal('single_select'),
+    options: z.array(agentUserInputOptionSchema).min(1),
+}).strict()
+
+export const agentUserInputQuestionSchema = z.discriminatedUnion('type', [
+    agentUserInputTextQuestionSchema,
+    agentUserInputSingleSelectQuestionSchema,
+])
+
+export const agentUserInputAnswersSchema = z.record(z.string().min(1), jsonValueSchema)
+
+export type AgentUserInputOption = z.infer<typeof agentUserInputOptionSchema>
+export type AgentUserInputTextQuestion = z.infer<typeof agentUserInputTextQuestionSchema>
+export type AgentUserInputSingleSelectQuestion = z.infer<typeof agentUserInputSingleSelectQuestionSchema>
+export type AgentUserInputQuestion = z.infer<typeof agentUserInputQuestionSchema>
+export type AgentUserInputAnswers = z.infer<typeof agentUserInputAnswersSchema>

package/src/protocol/agent-work.ts

@@ -0,0 +1,100 @@
+import z from 'zod'
+
+export const agentWorkStatusSchema = z.enum(['pending', 'in_progress', 'completed'])
+
+export const agentWorkItemSchema = z.object({
+    id: z.string().min(1),
+    title: z.string().min(1),
+    status: agentWorkStatusSchema,
+}).strict()
+
+const agentWorkSnapshotObservationSchema = z.object({
+    kind: z.literal('snapshot'),
+    items: z.array(agentWorkItemSchema),
+}).strict().superRefine(({ items }, context) => {
+    const seenIds = new Set<string>()
+
+    for (const [index, item] of items.entries()) {
+        if (seenIds.has(item.id)) {
+            context.addIssue({
+                code: 'custom',
+                message: 'Snapshot item ids must be unique.',
+                path: ['items', index, 'id'],
+            })
+        }
+        seenIds.add(item.id)
+    }
+})
+
+export const agentWorkObservationSchema = z.discriminatedUnion('kind', [
+    agentWorkSnapshotObservationSchema,
+    z.object({
+        kind: z.literal('item_observed'),
+        item: agentWorkItemSchema,
+    }).strict(),
+    z.object({
+        kind: z.literal('item_renamed'),
+        itemId: z.string().min(1),
+        title: z.string().min(1),
+    }).strict(),
+    z.object({
+        kind: z.literal('item_status_changed'),
+        itemId: z.string().min(1),
+        status: agentWorkStatusSchema,
+    }).strict(),
+    z.object({
+        kind: z.literal('item_removed'),
+        itemId: z.string().min(1),
+    }).strict(),
+])
+
+export const agentWorkStateSchema = z.object({
+    items: z.array(agentWorkItemSchema),
+}).strict()
+
+export type AgentWorkStatus = z.infer<typeof agentWorkStatusSchema>
+export type AgentWorkItem = z.infer<typeof agentWorkItemSchema>
+export type AgentWorkObservation = z.infer<typeof agentWorkObservationSchema>
+export type AgentWorkState = z.infer<typeof agentWorkStateSchema>
+
+export function applyAgentWorkObservations(
+    state: AgentWorkState,
+    observations: readonly AgentWorkObservation[],
+): AgentWorkState {
+    let items = state.items.map(item => ({ ...item }))
+
+    for (const observation of observations) {
+        switch (observation.kind) {
+            case 'snapshot':
+                items = observation.items.map(item => ({ ...item }))
+                break
+            case 'item_observed': {
+                const existingIndex = items.findIndex(item => item.id === observation.item.id)
+                if (existingIndex === -1)
+                    items = [...items, { ...observation.item }]
+                else
+                    items = items.map((item, index) => index === existingIndex ? { ...observation.item } : item)
+                break
+            }
+            case 'item_renamed':
+                items = items.map(item => item.id === observation.itemId
+                    ? { ...item, title: observation.title }
+                    : item)
+                break
+            case 'item_status_changed':
+                items = items.map(item => item.id === observation.itemId
+                    ? { ...item, status: observation.status }
+                    : item)
+                break
+            case 'item_removed':
+                items = items.filter(item => item.id !== observation.itemId)
+                break
+            default: {
+                const exhaustiveObservation: never = observation
+                void exhaustiveObservation
+            }
+        }
+    }
+
+    return { items }
+}

package/src/protocol/index.ts

@@ -0,0 +1,13 @@
+export * from './agent-command'
+export * from './agent-content'
+export * from './agent-error'
+export * from './agent-event'
+export * from './agent-json'
+export * from './agent-metadata'
+export * from './agent-model'
+export * from './agent-overflow'
+export * from './agent-presentation'
+export * from './agent-provider'
+export * from './agent-tool'
+export * from './agent-usage'
+export * from './agent-user-input'

package/src/provenance.gen.ts

@@ -0,0 +1,6 @@
+// Generated by scripts/write-provenance.ts. Do not edit by hand.
+export const generatedProvenance = {
+    version: "0.0.0",
+    sha: "3a023ce55b472e60cc194b759feac98f7ae61dba",
+    buildTime: "2026-09-04T18:05:02.217Z",
+} as const

package/src/provenance.ts

@@ -0,0 +1,27 @@
+import { generatedProvenance } from './provenance.gen'
+
+export interface AgentCoreProvenance {
+    /** Published package version, or `0.0.0-development` for a checkout. */
+    readonly version: string
+    /** Full git sha of the source that produced this build. */
+    readonly sha: string
+    /** ISO-8601 timestamp of the provenance generation. */
+    readonly buildTime: string
+    /** True when running from an unpublished development checkout. */
+    readonly isDevelopmentBuild: boolean
+}
+
+/**
+ * Identity of the agent-core build embedded in a process. Consumers record it in
+ * sandbox image/snapshot provenance so the immutable-sandbox invariant can be
+ * checked centrally: a snapshot built against one agent-core version is never
+ * served by a control plane expecting another.
+ */
+export function agentCoreProvenance(): AgentCoreProvenance {
+    return {
+        version: generatedProvenance.version,
+        sha: generatedProvenance.sha,
+        buildTime: generatedProvenance.buildTime,
+        isDevelopmentBuild: generatedProvenance.version.endsWith('-development'),
+    }
+}

package/src/supervisor-protocol/agent-event-wrapper.ts

@@ -0,0 +1,179 @@
+import type { AgentEvent } from '../protocol'
+import z from 'zod'
+import {
+    contextCompactionCompletedAgentEventSchema,
+    contextCompactionStartedAgentEventSchema,
+    errorAgentEventSchema,
+    messageDeltaAgentEventSchema,
+    messageEndedAgentEventSchema,
+    messageStartedAgentEventSchema,
+    reasoningEndedAgentEventSchema,
+    reasoningStartedAgentEventSchema,
+    reasoningSummaryDeltaAgentEventSchema,
+    sessionConfiguredAgentEventSchema,
+    sessionEndedAgentEventSchema,
+    sessionSkillsUpdatedAgentEventSchema,
+    sessionStartedAgentEventSchema,
+    sessionStateChangedAgentEventSchema,
+    subagentEndedAgentEventSchema,
+    subagentProgressAgentEventSchema,
+    subagentStartedAgentEventSchema,
+    toolCallCompletedAgentEventSchema,
+    toolCallStartedAgentEventSchema,
+    toolOutputDeltaAgentEventSchema,
+    turnEndedAgentEventSchema,
+    turnStartedAgentEventSchema,
+    usageAgentEventSchema,
+    userInputRequestedAgentEventSchema,
+    userInputResolvedAgentEventSchema,
+    workObservedAgentEventSchema,
+} from '../protocol'
+
+export type WrappedAgentEventType<TType extends AgentEvent['type'] = AgentEvent['type']> = `agent.${TType}`
+export type WrappedAgentEvent<TEvent extends AgentEvent = AgentEvent> = TEvent extends AgentEvent
+    ? Omit<TEvent, 'type'> & { type: WrappedAgentEventType<TEvent['type']> }
+    : never
+
+export const wrappedSessionStartedAgentEventSchema = sessionStartedAgentEventSchema.extend({
+    type: z.literal('agent.session.started'),
+}).strict()
+
+export const wrappedSessionConfiguredAgentEventSchema = sessionConfiguredAgentEventSchema.extend({
+    type: z.literal('agent.session.configured'),
+}).strict()
+
+export const wrappedSessionSkillsUpdatedAgentEventSchema = sessionSkillsUpdatedAgentEventSchema.extend({
+    type: z.literal('agent.session.skills.updated'),
+}).strict()
+
+export const wrappedSessionStateChangedAgentEventSchema = sessionStateChangedAgentEventSchema.extend({
+    type: z.literal('agent.session.state.changed'),
+}).strict()
+
+export const wrappedSessionEndedAgentEventSchema = sessionEndedAgentEventSchema.extend({
+    type: z.literal('agent.session.ended'),
+}).strict()
+
+export const wrappedTurnStartedAgentEventSchema = turnStartedAgentEventSchema.extend({
+    type: z.literal('agent.turn.started'),
+}).strict()
+
+export const wrappedTurnEndedAgentEventSchema = turnEndedAgentEventSchema.extend({
+    type: z.literal('agent.turn.ended'),
+}).strict()
+
+export const wrappedWorkObservedAgentEventSchema = workObservedAgentEventSchema.extend({
+    type: z.literal('agent.work.observed'),
+}).strict()
+
+export const wrappedMessageStartedAgentEventSchema = messageStartedAgentEventSchema.extend({
+    type: z.literal('agent.message.started'),
+}).strict()
+
+export const wrappedMessageDeltaAgentEventSchema = messageDeltaAgentEventSchema.extend({
+    type: z.literal('agent.message.delta'),
+}).strict()
+
+export const wrappedMessageEndedAgentEventSchema = messageEndedAgentEventSchema.extend({
+    type: z.literal('agent.message.ended'),
+}).strict()
+
+export const wrappedReasoningStartedAgentEventSchema = reasoningStartedAgentEventSchema.extend({
+    type: z.literal('agent.reasoning.started'),
+}).strict()
+
+export const wrappedReasoningSummaryDeltaAgentEventSchema = reasoningSummaryDeltaAgentEventSchema.extend({
+    type: z.literal('agent.reasoning.summary.delta'),
+}).strict()
+
+export const wrappedReasoningEndedAgentEventSchema = reasoningEndedAgentEventSchema.extend({
+    type: z.literal('agent.reasoning.ended'),
+}).strict()
+
+export const wrappedToolCallStartedAgentEventSchema = toolCallStartedAgentEventSchema.extend({
+    type: z.literal('agent.tool.call.started'),
+}).strict()
+
+export const wrappedToolOutputDeltaAgentEventSchema = toolOutputDeltaAgentEventSchema.extend({
+    type: z.literal('agent.tool.output.delta'),
+}).strict()
+
+export const wrappedToolCallCompletedAgentEventSchema = toolCallCompletedAgentEventSchema.extend({
+    type: z.literal('agent.tool.call.completed'),
+}).strict()
+
+export const wrappedSubagentStartedAgentEventSchema = subagentStartedAgentEventSchema.extend({
+    type: z.literal('agent.subagent.started'),
+}).strict()
+
+export const wrappedSubagentProgressAgentEventSchema = subagentProgressAgentEventSchema.extend({
+    type: z.literal('agent.subagent.progress'),
+}).strict()
+
+export const wrappedSubagentEndedAgentEventSchema = subagentEndedAgentEventSchema.extend({
+    type: z.literal('agent.subagent.ended'),
+}).strict()
+
+export const wrappedUsageAgentEventSchema = usageAgentEventSchema.extend({
+    type: z.literal('agent.usage'),
+}).strict()
+
+export const wrappedContextCompactionStartedAgentEventSchema = contextCompactionStartedAgentEventSchema.extend({
+    type: z.literal('agent.context.compaction.started'),
+}).strict()
+
+export const wrappedContextCompactionCompletedAgentEventSchema = contextCompactionCompletedAgentEventSchema.extend({
+    type: z.literal('agent.context.compaction.completed'),
+}).strict()
+
+export const wrappedUserInputRequestedAgentEventSchema = userInputRequestedAgentEventSchema.extend({
+    type: z.literal('agent.user-input.requested'),
+}).strict()
+
+export const wrappedUserInputResolvedAgentEventSchema = userInputResolvedAgentEventSchema.extend({
+    type: z.literal('agent.user-input.resolved'),
+}).strict()
+
+export const wrappedErrorAgentEventSchema = errorAgentEventSchema.extend({
+    type: z.literal('agent.error'),
+}).strict()
+
+export const wrappedAgentEventSchema = z.discriminatedUnion('type', [
+    wrappedSessionStartedAgentEventSchema,
+    wrappedSessionConfiguredAgentEventSchema,
+    wrappedSessionSkillsUpdatedAgentEventSchema,
+    wrappedSessionStateChangedAgentEventSchema,
+    wrappedSessionEndedAgentEventSchema,
+    wrappedTurnStartedAgentEventSchema,
+    wrappedTurnEndedAgentEventSchema,
+    wrappedWorkObservedAgentEventSchema,
+    wrappedMessageStartedAgentEventSchema,
+    wrappedMessageDeltaAgentEventSchema,
+    wrappedMessageEndedAgentEventSchema,
+    wrappedReasoningStartedAgentEventSchema,
+    wrappedReasoningSummaryDeltaAgentEventSchema,
+    wrappedReasoningEndedAgentEventSchema,
+    wrappedToolCallStartedAgentEventSchema,
+    wrappedToolOutputDeltaAgentEventSchema,
+    wrappedToolCallCompletedAgentEventSchema,
+    wrappedSubagentStartedAgentEventSchema,
+    wrappedSubagentProgressAgentEventSchema,
+    wrappedSubagentEndedAgentEventSchema,
+    wrappedUsageAgentEventSchema,
+    wrappedContextCompactionStartedAgentEventSchema,
+    wrappedContextCompactionCompletedAgentEventSchema,
+    wrappedUserInputRequestedAgentEventSchema,
+    wrappedUserInputResolvedAgentEventSchema,
+    wrappedErrorAgentEventSchema,
+])
+
+export function wrapAgentEventType<TType extends AgentEvent['type']>(type: TType): WrappedAgentEventType<TType> {
+    return `agent.${type}`
+}
+
+export function wrapAgentEvent<TEvent extends AgentEvent>(event: TEvent): WrappedAgentEvent<TEvent> {
+    return {
+        ...event,
+        type: wrapAgentEventType(event.type),
+    }
+}

package/src/supervisor-protocol/bootstrap-rejection-receipt.ts

@@ -0,0 +1,3 @@
+// WHATWG permits 3000–4999 and 123 reason bytes; pinned Bun preserves this three-byte reason in its server close callback.
+export const supervisorBootstrapRejectionReceiptCloseCode = 4409
+export const supervisorBootstrapRejectionReceiptCloseReason = 'ack'

package/src/supervisor-protocol/bootstrap.ts

@@ -0,0 +1,126 @@
+import z from 'zod'
+import { agentProviderIdSchema, agentReasoningEffortSchema } from '../protocol'
+import { wireCommandBodySchema } from './command-body'
+import { sessionProfileSchema } from './profile'
+
+/**
+ * Absolute, normalized POSIX path: no trailing slash, no empty, `.` or `..`
+ * segments, no NUL bytes. The coding-agent product always sends
+ * `/home/user/workspace`; agent-api sends its prepared repository root.
+ */
+const absoluteDirectoryPathPattern = /^\/(?:[^/\0]+\/)*[^/\0]+$/u
+export const absoluteDirectoryPathSchema = z.string()
+    .max(4096)
+    .regex(absoluteDirectoryPathPattern)
+    .refine(value => value.split('/').every(segment => segment !== '.' && segment !== '..'), {
+        message: 'path must be normalized (no . or .. segments)',
+    })
+
+const repositorySchema = z.object({
+    id: z.string().min(1),
+    fullName: z.string().regex(/^[^/\s]+\/[^/\s]+$/u),
+    root: absoluteDirectoryPathSchema,
+    branch: z.string().min(1),
+}).strict()
+
+const gitIdentityNameSchema = z.string()
+    .min(1)
+    .max(200)
+    .refine(hasNoAsciiControlCharacters)
+const gitIdentityEmailSchema = z.string()
+    .min(3)
+    .max(320)
+    .regex(/^[^@<>\s]+@[^@<>\s]+$/u)
+    .refine(hasNoAsciiControlCharacters)
+const gitIdentitySchema = z.object({
+    name: gitIdentityNameSchema,
+    email: gitIdentityEmailSchema,
+}).strict()
+
+export const sessionBootstrapBodySchema = z.object({
+    sessionId: z.string().min(1),
+    agent: z.object({
+        provider: agentProviderIdSchema,
+        cwd: absoluteDirectoryPathSchema,
+        model: z.string().min(1).optional(),
+        reasoningEffort: agentReasoningEffortSchema.optional(),
+    }).strict(),
+    repositories: z.array(repositorySchema).superRefine((repositories, context) => {
+        const ids = new Set<string>()
+        const roots = new Set<string>()
+        for (const [index, repository] of repositories.entries()) {
+            if (ids.has(repository.id))
+                context.addIssue({ code: 'custom', path: [index, 'id'], message: 'repository id must be unique' })
+            if (roots.has(repository.root))
+                context.addIssue({ code: 'custom', path: [index, 'root'], message: 'repository root must be unique' })
+            ids.add(repository.id)
+            roots.add(repository.root)
+        }
+    }),
+    gitBotIdentity: gitIdentitySchema.optional(),
+    profile: sessionProfileSchema.optional(),
+    initialCommand: z.object({
+        commandId: z.string().min(1),
+        commandSeq: z.literal(1),
+        body: wireCommandBodySchema,
+    }).strict(),
+}).strict().superRefine((body, context) => {
+    const workspacePrefix = `${body.agent.cwd}/`
+    for (const [index, repository] of body.repositories.entries()) {
+        if (!repository.root.startsWith(workspacePrefix)) {
+            context.addIssue({
+                code: 'custom',
+                path: ['repositories', index, 'root'],
+                message: `repository root must be inside the agent cwd (${body.agent.cwd})`,
+            })
+        }
+    }
+    if (body.repositories.length > 0 && body.gitBotIdentity === undefined) {
+        context.addIssue({
+            code: 'custom',
+            path: ['gitBotIdentity'],
+            message: 'gitBotIdentity is required when repositories are selected',
+        })
+    }
+})
+
+export const sessionBootstrapGitTokenSchema = z.object({
+    token: z.string().min(1),
+    expiresAt: z.iso.datetime(),
+}).strict()
+
+/**
+ * Secrets handed to the supervisor at bootstrap and on every reconnect. They are
+ * memory-only on both sides: never persisted to SQLite, never part of the
+ * bootstrap hash, never logged. Keys are environment-variable shaped because
+ * `ProviderCredentialsSource.environmentFor` maps them straight into the harness
+ * child environment.
+ */
+export const ephemeralCredentialNameSchema = z.string().max(128).regex(/^[A-Z][A-Z0-9_]*$/u)
+export const ephemeralCredentialMaxValueBytes = 16 * 1024
+export const ephemeralCredentialsMaxEntries = 64
+
+export const ephemeralCredentialSchema = z.object({
+    value: z.string().min(1).refine(value => new TextEncoder().encode(value).byteLength <= ephemeralCredentialMaxValueBytes, {
+        message: `credential value must be at most ${ephemeralCredentialMaxValueBytes} bytes`,
+    }),
+    expiresAt: z.iso.datetime().optional(),
+}).strict()
+
+export const ephemeralCredentialsSchema = z.record(ephemeralCredentialNameSchema, ephemeralCredentialSchema)
+    .refine(value => Object.keys(value).length <= ephemeralCredentialsMaxEntries, {
+        message: `at most ${ephemeralCredentialsMaxEntries} credentials may be issued`,
+    })
+
+export type SessionBootstrapBody = z.infer<typeof sessionBootstrapBodySchema>
+export type SessionBootstrapRepository = SessionBootstrapBody['repositories'][number]
+export type SessionBootstrapGitToken = z.infer<typeof sessionBootstrapGitTokenSchema>
+export type EphemeralCredential = z.infer<typeof ephemeralCredentialSchema>
+export type EphemeralCredentials = z.infer<typeof ephemeralCredentialsSchema>
+
+function hasNoAsciiControlCharacters(value: string): boolean {
+    return [...value].every((character) => {
+        const codePoint = character.codePointAt(0)
+        return codePoint !== undefined && codePoint > 31 && codePoint !== 127
+    })
+}