admin/AirCoding
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

chore: push all design docs, V2 plan specs, and current working state

Browse Source 
Includes AirPlan design documents, AircOding-alpha1-plan, AirPlanV2,
AirPlan-ParaV2, AirPlan-Para V1 reference docs, and all working code
changes across packages.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
This commit is contained in:
AirCoding
2026-06-12 17:12:29 +08:00
parent 8f55c962bb
commit ae44be31d5
364 changed files with 46779 additions and 2812 deletions
Download Patch File Download Diff File Expand all files Collapse all files

294
packages/runtime/src/tools/ToolRegistry.ts
View File

@@ -29,6 +29,7 @@ export interface ToolExecutionContext {
project_root: string
agent_id: string
agent_type: AgentType
task_id?: string
task_scope?: PermissionContext['task_scope']
permission_profile?: PermissionContext['permission_profile']
}
@@ -110,18 +111,98 @@ export class ToolRegistry {
// Step 4: Evaluate permissions (layered per DD §9.2)
const decision = await this.permission_engine.evaluate(call, permission_context, definition)
// B.2: Emit tool.started event before execution
const startedAt = new Date().toISOString() as ISOTimeString
const eventPayload = {
tool_run_id: call.call_id,
call_id: call.call_id,
tool_name: call.name,
input_json: call.arguments || {},
started_at: startedAt,
agent_id: context.agent_id,
task_id: context.task_id,
session_id: context.session_id,
}
try {
await eventIngestor.ingest({
id: `tool_start_${call.call_id}_${Date.now()}`,
type: 'tool.started',
version: 1,
timestamp: startedAt,
session_id: context.session_id,
project_id: context.project_id,
source: { kind: 'tool' as const, id: context.agent_id },
route: [],
payload: eventPayload,
})
} catch (e) {
// Log but don't fail tool execution if event emission fails
console.warn('Failed to emit tool.started event:', e)
}
// Step 5: Branch on permission action (DD §9.3)
// Step 6: Execute branch
let result: ToolResultEnvelope
try {
const result = await this.execute_branch(decision, call, context)
// Step 7: Record decision (if enabled)
await this.permission_engine.record(decision)
return result
result = await this.execute_branch(decision, call, context)
} catch (error) {
// B.2: Emit tool.failed event on exception
const failedAt = new Date().toISOString() as ISOTimeString
const errorPayload = {
call_id: call.call_id,
tool_name: call.name,
completed_at: failedAt,
exit_code: 'error',
output_kind: 'error',
error: error instanceof Error ? error.message : String(error),
}
try {
await eventIngestor.ingest({
id: `tool_fail_${call.call_id}_${Date.now()}`,
type: 'tool.failed',
version: 1,
timestamp: failedAt,
session_id: context.session_id,
project_id: context.project_id,
source: { kind: 'tool' as const, id: context.agent_id },
route: [],
payload: errorPayload,
})
} catch (e) {
console.warn('Failed to emit tool.failed event:', e)
}
return create_error_result(call.call_id, 'execution_error', error instanceof Error ? error.message : String(error))
}
// B.2: Emit tool.completed event on success
const completedAt = new Date().toISOString() as ISOTimeString
const completedPayload = {
call_id: call.call_id,
tool_name: call.name,
completed_at: completedAt,
exit_code: 'ok',
output_kind: 'text',
}
try {
await eventIngestor.ingest({
id: `tool_end_${call.call_id}_${Date.now()}`,
type: 'tool.completed',
version: 1,
timestamp: completedAt,
session_id: context.session_id,
project_id: context.project_id,
source: { kind: 'tool' as const, id: context.agent_id },
route: [],
payload: completedPayload,
})
} catch (e) {
console.warn('Failed to emit tool.completed event:', e)
}
// Step 7: Record decision (if enabled)
await this.permission_engine.record(decision, context)
return result
}
/**
@@ -144,25 +225,135 @@ export class ToolRegistry {
return
}
// Permission check first (same as call)
// Permission check first (same branching as call)
const permission_context = this.build_permission_context(call, context)
const decision = await this.permission_engine.evaluate(call, permission_context, definition)
if (decision.action !== 'allow' && decision.action !== 'announce_then_run') {
yield create_error_result(call.call_id, 'permission_denied', decision.reason)
return
// Emit tool.started event before execution
const startedAt = new Date().toISOString() as ISOTimeString
try {
await eventIngestor.ingest({
id: `tool_start_${call.call_id}_${Date.now()}`,
type: 'tool.started',
version: 1,
timestamp: startedAt,
session_id: context.session_id,
project_id: context.project_id,
source: { kind: 'tool' as const, id: context.agent_id },
route: [],
payload: {
call_id: call.call_id,
tool_name: call.name,
started_at: startedAt,
agent_id: context.agent_id,
task_id: context.task_id,
session_id: context.session_id,
},
})
} catch (e) {
console.warn('Failed to emit tool.started event (streaming):', e)
}
// Full permission branching (same as execute_branch)
switch (decision.action) {
case 'deny':
yield create_error_result(call.call_id, 'permission_denied', decision.reason)
return
case 'block':
yield create_error_result(call.call_id, 'blocked', `Action blocked: ${decision.reason}`)
return
case 'refuse':
yield create_error_result(call.call_id, 'policy_error', `Refused: ${decision.reason}`)
return
case 'ask_user': {
const prompt_id = `perm_${crypto.randomUUID()}`
try {
await eventIngestor.ingest({
id: `evt_${prompt_id}`,
type: 'permission.prompt.requested',
version: 1,
session_id: context.session_id,
project_id: context.project_id,
timestamp: new Date().toISOString(),
source: { kind: 'tool', id: call.name },
route: ['tool_registry', 'permission'],
payload: {
prompt_id,
subject: call.name,
risk_level: decision.risk_level,
reason: decision.reason,
options: ['allow_once', 'deny'],
default_option: 'deny',
request_ref: { call_id: call.call_id, tool_name: call.name, agent_id: context.agent_id },
},
})
} catch (e) {
console.warn('Failed to emit permission.prompt.requested:', e)
}
const selected = await this.wait_for_permission(prompt_id, context)
if (selected !== 'allow_once' && selected !== 'allow') {
yield create_error_result(call.call_id, 'permission_denied', `User selected ${selected}`)
return
}
break
}
case 'announce_then_run':
// Fall through to execution with announced metadata
break
case 'allow':
break
default:
yield create_error_result(call.call_id, 'invalid_decision', `Unknown action: ${decision.action}`)
return
}
let saw_final = false
let lastError: Error | undefined
for await (const chunk of this.execute_streaming(call, context, executor)) {
if (chunk.metadata && (chunk.metadata as any).is_final === true) saw_final = true
yield chunk
try {
for await (const chunk of this.execute_streaming(call, context, executor)) {
if (chunk.metadata && (chunk.metadata as any).is_final === true) saw_final = true
if (decision.action === 'announce_then_run' && chunk.metadata) {
(chunk.metadata as any).announced = true
}
yield chunk
}
} catch (error) {
lastError = error instanceof Error ? error : new Error(String(error))
yield create_error_result(call.call_id, 'execution_error', lastError.message)
}
if (!saw_final) {
// Emit tool.completed or tool.failed event
const endAt = new Date().toISOString() as ISOTimeString
const endEventType = lastError ? 'tool.failed' : 'tool.completed'
try {
await eventIngestor.ingest({
id: `tool_${lastError ? 'fail' : 'end'}_${call.call_id}_${Date.now()}`,
type: endEventType,
version: 1,
timestamp: endAt,
session_id: context.session_id,
project_id: context.project_id,
source: { kind: 'tool' as const, id: context.agent_id },
route: [],
payload: {
call_id: call.call_id,
tool_name: call.name,
completed_at: endAt,
exit_code: lastError ? 'error' : 'ok',
output_kind: lastError ? 'error' : 'text',
...(lastError ? { error: lastError.message } : {}),
},
})
} catch (e) {
console.warn(`Failed to emit ${endEventType} event (streaming):`, e)
}
if (!saw_final && !lastError) {
yield create_error_result(call.call_id, 'no_final_result', 'Streaming tool did not produce final result')
}
await this.permission_engine.record(decision, context)
}
/**
@@ -250,6 +441,12 @@ export class ToolRegistry {
if (!executor) {
return create_error_result(call.call_id, 'executor_not_found', 'Executor not registered')
}
// FR-011: Handle backup requirement for out-of-project writes
if ((decision as any).backup_required && (decision as any).backup_path) {
await this.perform_backup(call, (decision as any).backup_path)
}
return this.execute_executor_final(executor, call, ctx)
}
@@ -259,6 +456,12 @@ export class ToolRegistry {
if (!executor) {
return create_error_result(call.call_id, 'executor_not_found', 'Executor not registered')
}
// FR-011: Handle backup requirement for out-of-project writes
if ((decision as any).backup_required && (decision as any).backup_path) {
await this.perform_backup(call, (decision as any).backup_path)
}
const result = await this.execute_executor_final(executor, call, ctx)
return {
...result,
@@ -400,6 +603,69 @@ export class ToolRegistry {
}
yield await result
}
/**
* FR-011: Perform backup before out-of-project write.
* Creates backup in .air/local/backups/
*/
private async perform_backup(call: ToolCall, backup_path: string): Promise<void> {
try {
const { mkdirSync, existsSync, cpSync } = await import('fs')
const { dirname } = await import('path')
// Extract source path from tool call
const source_path = this.extract_source_path(call)
if (!source_path || !existsSync(source_path)) {
console.warn('Backup skipped: source file does not exist:', source_path)
return
}
// Ensure backup directory exists
const backup_dir = dirname(backup_path)
if (!existsSync(backup_dir)) {
mkdirSync(backup_dir, { recursive: true })
}
// Copy source to backup location
cpSync(source_path, backup_path)
// Emit backup event
await eventIngestor.ingest({
id: `backup_${Date.now()}`,
type: 'file.backup.created',
version: 1,
timestamp: new Date().toISOString(),
session_id: call.call_id, // Use call_id as session_id placeholder
project_id: this.project_root,
source: { kind: 'tool', id: 'tool_registry' },
route: ['tool_registry', 'backup'],
payload: {
original_path: source_path,
backup_path,
tool_name: call.name,
call_id: call.call_id
}
})
} catch (e) {
console.error('Backup failed:', e)
// Continue with operation even if backup fails - log but don't block
}
}
/**
* Extract source file path from tool call for backup.
*/
private extract_source_path(call: ToolCall): string | null {
const args = call.arguments as Record<string, unknown>
const path_keys = ['path', 'file', 'file_path', 'source', 'target']
for (const key of path_keys) {
if (typeof args[key] === 'string') {
return args[key] as string
}
}
return null
}
}
export function createToolRegistry(project_root: string): ToolRegistry {