@meistrari/agent-core 0.0.0 → 0.1.0

package/src/agents/claude/claude-tool-mapper.ts

@@ -0,0 +1,186 @@
+import type { Options } from '@anthropic-ai/claude-agent-sdk'
+import type { AgentRunMetadata, AgentUserInputQuestion, JsonValue } from '../../protocol'
+import type { AgentTool } from '../agent-tool'
+import { tool as claudeTool, createSdkMcpServer } from '@anthropic-ai/claude-agent-sdk'
+import { isAppError } from '../../errors'
+import { AgentProviderProtocolError } from '../agent-runtime-error'
+import { agentToolActorDenialMessage, agentToolAllowsActor } from '../agent-tool'
+import { runAgentTool } from '../agent-tool-runner'
+
+export const CLAUDE_AGENT_TOOL_SERVER = 'coding_agent'
+export const CLAUDE_CODE_TOOL_USE_ID_META_KEY = 'claudecode/toolUseId'
+
+const UNEXPECTED_TOOL_FAILURE_MESSAGE = 'The tool could not be executed.'
+
+interface ClaudeMcpToolExtra {
+    _meta?: {
+        [CLAUDE_CODE_TOOL_USE_ID_META_KEY]?: unknown
+    }
+}
+
+interface ClaudeToolUserInputRequest {
+    turnId: string
+    toolCallId: string
+    prompt: string
+    questions: AgentUserInputQuestion[]
+}
+
+interface ClaudeToolRuntimeAttachment {
+    metadata: AgentRunMetadata
+    requestUserInput: (input: ClaudeToolUserInputRequest) => Promise<{ requestId: string }>
+}
+
+interface ClaudeToolRuntimeRef {
+    metadata: () => AgentRunMetadata
+    turnId: () => string
+    requestUserInput: (input: ClaudeToolUserInputRequest) => Promise<{ requestId: string }>
+}
+
+type AttachableClaudeToolRuntimeRef = ClaudeToolRuntimeRef & {
+    attach: (runtime: ClaudeToolRuntimeAttachment) => void
+}
+
+export function createClaudeToolRuntimeRef(input: { turnId: () => string | undefined }): AttachableClaudeToolRuntimeRef {
+    let runtime: ClaudeToolRuntimeAttachment | undefined
+
+    return {
+        attach: attached => runtime = attached,
+        metadata: () => requireAttachedRuntime(runtime).metadata,
+        turnId: () => {
+            const turnId = input.turnId()
+            if (turnId)
+                return turnId
+            throw new AgentProviderProtocolError({ message: 'Claude invoked a runtime tool without an active turn id.' })
+        },
+        requestUserInput: async request => await requireAttachedRuntime(runtime).requestUserInput(request),
+    }
+}
+
+export function toClaudeMcpServers(input: {
+    tools: readonly AgentTool[]
+    runtime: ClaudeToolRuntimeRef
+    signal: AbortSignal
+}): NonNullable<Options['mcpServers']> | undefined {
+    if (input.tools.length === 0)
+        return undefined
+
+    return {
+        [CLAUDE_AGENT_TOOL_SERVER]: createSdkMcpServer({
+            name: CLAUDE_AGENT_TOOL_SERVER,
+            version: '0.1.0',
+            tools: input.tools.map(runtimeTool => claudeTool(
+                runtimeTool.name,
+                runtimeTool.description,
+                runtimeTool.inputShape,
+                async (args: JsonValue, extra: unknown) => {
+                    const metadata = input.runtime.metadata()
+                    const turnId = input.runtime.turnId()
+                    const toolCallId = requiredToolCallId(extra)
+                    try {
+                        const result = await runAgentTool({
+                            tool: runtimeTool,
+                            // The PreToolUse hook is the actor gate because MCP handler metadata has no actor identity.
+                            actor: 'main',
+                            rawInput: args,
+                            context: {
+                                provider: 'claude',
+                                sessionId: metadata.sessionId,
+                                providerSessionId: metadata.providerSessionId,
+                                turnId,
+                                cwd: metadata.cwd,
+                                toolCallId,
+                                signal: input.signal,
+                                requestUserInput: async request => await input.runtime.requestUserInput({ ...request, turnId, toolCallId }),
+                            },
+                        })
+                        return {
+                            isError: !result.success,
+                            content: result.content,
+                        }
+                    }
+                    catch (error) {
+                        if (isAppError(error))
+                            throw error
+                        return unexpectedToolFailure()
+                    }
+                },
+            )),
+        }),
+    }
+}
+
+export function claudeAllowedToolNames(tools: readonly AgentTool[]): string[] {
+    return tools.map(runtimeTool => claudeToolName(runtimeTool.name))
+}
+
+export function claudeToolActorHooks(tools: readonly AgentTool[]): Options['hooks'] {
+    const toolsByName = new Map(
+        tools
+            .filter(runtimeTool => runtimeTool.actorScope === 'main')
+            .map(runtimeTool => [claudeToolName(runtimeTool.name), runtimeTool] as const),
+    )
+    if (toolsByName.size === 0)
+        return undefined
+
+    return {
+        PreToolUse: [{
+            hooks: [async (hookInput) => {
+                if (hookInput.hook_event_name !== 'PreToolUse')
+                    return {}
+
+                const runtimeTool = toolsByName.get(hookInput.tool_name)
+                const actor = hookInput.agent_id === undefined ? 'main' : 'subagent'
+                if (!runtimeTool || agentToolAllowsActor(runtimeTool, actor))
+                    return {}
+
+                return {
+                    hookSpecificOutput: {
+                        hookEventName: 'PreToolUse',
+                        permissionDecision: 'deny',
+                        permissionDecisionReason: agentToolActorDenialMessage(runtimeTool),
+                    },
+                }
+            }],
+        }],
+    }
+}
+
+function claudeToolName(toolName: string): string {
+    return `mcp__${CLAUDE_AGENT_TOOL_SERVER}__${toolName}`
+}
+
+function unexpectedToolFailure(): { isError: true, content: [{ type: 'text', text: string }] } {
+    return {
+        isError: true,
+        content: [{ type: 'text', text: UNEXPECTED_TOOL_FAILURE_MESSAGE }],
+    }
+}
+
+function requireAttachedRuntime(runtime: ClaudeToolRuntimeAttachment | undefined): ClaudeToolRuntimeAttachment {
+    if (runtime)
+        return runtime
+    throw new AgentProviderProtocolError({ message: 'Claude invoked a runtime tool before run metadata was available.' })
+}
+
+function requiredToolCallId(extra: unknown): string {
+    const toolCallId = toolCallIdFromExtra(extra)
+    if (toolCallId)
+        return toolCallId
+    throw new AgentProviderProtocolError({ message: 'Claude invoked a runtime tool without a provider tool call id.' })
+}
+
+function toolCallIdFromExtra(extra: unknown): string | undefined {
+    if (!isClaudeMcpToolExtra(extra))
+        return undefined
+
+    const value = extra._meta?.[CLAUDE_CODE_TOOL_USE_ID_META_KEY]
+    return typeof value === 'string' && value.trim() ? value : undefined
+}
+
+function isClaudeMcpToolExtra(value: unknown): value is ClaudeMcpToolExtra {
+    if (typeof value !== 'object' || value === null)
+        return false
+
+    const meta = (value as { _meta?: unknown })._meta
+    return meta === undefined || (typeof meta === 'object' && meta !== null)
+}

package/src/agents/claude/index.ts

@@ -0,0 +1 @@
+export * from './claude-provider'

package/src/agents/codex/codex-auth.ts

@@ -0,0 +1,34 @@
+export interface CodexAuthTokens {
+    accessToken: string
+    accessTokenGeneration: number
+    accessTokenFingerprint: string
+    chatgptAccountId: string
+    chatgptPlanType?: string | null
+}
+
+export interface CodexAuthRefreshInput {
+    reason: 'unauthorized'
+    rejectedTokenGeneration: number
+    rejectedTokenFingerprint: string
+}
+
+export type CodexAuthTokenRequest = Readonly<{
+    signal?: AbortSignal
+}>
+
+export interface CodexAuthProvider {
+    getAuthTokens: (input?: CodexAuthTokenRequest) => Promise<CodexAuthTokens>
+    refreshAuthTokens: (input: CodexAuthRefreshInput) => Promise<CodexAuthTokens>
+}
+
+export interface CodexApiKeyCredentials {
+    apiKey: string
+}
+
+export interface CodexApiKeyAuthProvider {
+    getApiKey: (input?: CodexAuthTokenRequest) => Promise<CodexApiKeyCredentials>
+}
+
+export type CodexAuthentication
+    = | { kind: 'chatgpt', provider: CodexAuthProvider }
+        | { kind: 'api-key', provider: CodexApiKeyAuthProvider, modelProvider?: string }

package/src/agents/codex/codex-command-mapper.ts

@@ -0,0 +1,78 @@
+import type { AgentAuthor, AgentInputBlock, AgentPrompt, AgentReasoningEffort } from '../../protocol'
+import type { AgentSenderContext } from '../agent-operation'
+import type { AgentInputAttachmentPreparation, AgentInputAttachmentProjection } from '../materialized-input-attachment'
+import type { CodexTurnStartParams, CodexUserInput } from './codex-protocol'
+import { AgentUnsupportedPromptBlockError } from '../agent-runtime-error'
+import { renderAuthorContext } from '../author-context'
+import { filesystemFallbackLabel, nativeAttachmentLabel, nativeImageMimeType, readAttachmentBytes } from '../input-attachment-preparation'
+
+interface CodexUserInputMapperInput {
+    prompt: AgentPrompt
+    origin?: 'user' | 'supervisor'
+    author?: AgentAuthor
+    senderContext?: AgentSenderContext
+}
+
+export function toCodexUserInput(input: CodexUserInputMapperInput): CodexUserInput[] {
+    const { prompt, origin = 'user', author, senderContext } = input
+    const blocks = prompt.blocks.map(toCodexInputBlock)
+    return origin === 'user' && author
+        ? [{ type: 'text', text: renderAuthorContext(author, senderContext), text_elements: [] }, ...blocks]
+        : blocks
+}
+
+export async function prepareCodexUserInput(input: CodexUserInputMapperInput & { preparation: AgentInputAttachmentPreparation }): Promise<CodexUserInput[]> {
+    input.preparation.signal.throwIfAborted()
+    const userInput = toCodexUserInput(input)
+    const records: AgentInputAttachmentProjection[] = []
+
+    for (const attachment of input.preparation.attachments) {
+        const bytes = await readAttachmentBytes(attachment, input.preparation.signal)
+        const imageMimeType = nativeImageMimeType(attachment.mediaType, bytes)
+        if (imageMimeType) {
+            userInput.push(
+                { type: 'text', text: nativeAttachmentLabel(attachment), text_elements: [] },
+                { type: 'localImage', path: attachment.localPath },
+            )
+            records.push({
+                attachmentId: attachment.attachmentId,
+                ordinal: attachment.ordinal,
+                sha256: attachment.sha256,
+                route: 'native',
+                nativeKind: 'image',
+            })
+            continue
+        }
+
+        userInput.push({ type: 'text', text: filesystemFallbackLabel(attachment), text_elements: [] })
+        records.push({
+            attachmentId: attachment.attachmentId,
+            ordinal: attachment.ordinal,
+            sha256: attachment.sha256,
+            route: 'filesystem_fallback',
+        })
+    }
+
+    input.preparation.recordInputAttachmentProjections(records)
+    return userInput
+}
+
+export function codexEffort(effort: AgentReasoningEffort | undefined): CodexTurnStartParams['effort'] | undefined {
+    if (effort === undefined)
+        return undefined
+    if (effort === 'max')
+        return 'xhigh'
+    return effort
+}
+
+function toCodexInputBlock(block: AgentInputBlock): CodexUserInput {
+    if (block.type === 'text') {
+        return { type: 'text', text: block.text, text_elements: [] }
+    }
+
+    if (block.type === 'image' && block.source.kind === 'url') {
+        return { type: 'image', url: block.source.url }
+    }
+
+    throw new AgentUnsupportedPromptBlockError({ provider: 'codex', blockType: block.type })
+}