@kingsoftcloud/agentkit-harness-ui 0.0.0-stage → 0.0.1

package/src/host/session-task-events.mjs

@@ -0,0 +1,247 @@
+import { initialState, reduce } from '@kingsoftcloud/agentkit-harness-ui/reducer';
+import { previewToolInput } from '@kingsoftcloud/agentkit-harness-ui/input-preview';
+import { nativeRunIsInactive } from './state/native-outcome.mjs';
+
+const textOf = content => (Array.isArray(content) ? content : []).filter(part => part.type === 'text').map(part => part.text).join('\n');
+const nativeInterruptionMessages = Object.freeze({
+  NATIVE_BACKGROUND_RESULT_UNKNOWN: '已结束等待，原命令结果仍未知；不会重跑。',
+  NATIVE_READ_INTERRUPTED: '读取结果未确认；本轮已停止，需要获取新的观察结果。',
+  NATIVE_RESOURCE_RESULT_UNKNOWN: '旧浏览器已隔离，原操作结果仍未知；后续必须获取新观察。',
+});
+
+const outcomeFact = (fact, callId, turn, sessionId, status) => fact?.contract === 'agentkit.native-tool-outcome/v1'
+  && fact.status === status && typeof fact.runId === 'string' && fact.runId
+  && typeof fact.sessionId === 'string' && fact.sessionId && (!sessionId || fact.sessionId === sessionId)
+  && typeof fact.callId === 'string' && fact.callId && fact.callId === callId
+  && Number.isSafeInteger(fact.turn) && fact.turn === turn;
+const uncertainFact = (fact, callId, turn, sessionId) => outcomeFact(fact, callId, turn, sessionId, 'uncertain');
+
+/** Enrich old Session projections from scoped journal facts without rewriting them. */
+export function nativeHistoricalToolState(state, status, turn, sessionId) {
+  const view = status?.uncertainTools;
+  if (view?.contract !== 'agentkit.native-session-tool-outcomes/v1' || view.sessionId !== sessionId || !Array.isArray(view.facts)) return state;
+  let changed = false;
+  const items = state.items.map(item => {
+    if (item.kind !== 'tool') return item;
+    const fact = view.facts.find(fact => ['uncertain', 'not_dispatched'].includes(fact.status)
+      && outcomeFact(fact, item.callId, turn, sessionId, fact.status));
+    if (!fact) return item;
+    changed = true;
+    return { ...item, status: fact.status, progress: fact.status === 'uncertain' ? '执行结果未知，需要核对回执' : null };
+  });
+  return changed ? { ...state, items } : state;
+}
+const commandTools = new Set(['run_command', 'read_command_output']);
+
+function commandDisplay(name, value) {
+  if (!commandTools.has(name) || !value || typeof value !== 'object'
+    || typeof value.stdout !== 'string' && typeof value.stderr !== 'string') return undefined;
+  return { kind: 'command_output', stdout: value.stdout ?? '', stderr: value.stderr ?? '',
+    ...(Number.isInteger(value.exit_code) ? { exit: value.exit_code } : {}),
+    ...(typeof value.cwd === 'string' ? { cwd: value.cwd } : {}) };
+}
+
+/** Transport adapter only. The package owns lifecycle and presentation. */
+function admittedContextMarker(event, sessionId) {
+  const data = event.data, marker = data?.marker;
+  if (!sessionId || event.ignorable !== true || Object.hasOwn(event, 'surfaceOp')
+    || data?.contract !== 'agentkit.native-context-presentation/v1' || data.sessionId !== sessionId
+    || typeof data.runId !== 'string' || !data.runId.trim() || data.runId.length > 256
+    || !Number.isSafeInteger(data.turn) || data.turn < 1 || !/^ak-native-[a-f0-9]{64}$/.test(marker?.id ?? '')
+    || !['completed', 'failed', 'interrupted'].includes(marker.status) || marker.origin !== 'auto'
+    || !['start', 'tool', 'message'].includes(marker.after?.kind)
+    || marker.after.kind !== 'start' && !/^ak-native-[a-f0-9]{64}$/.test(marker.after.id ?? '')) return null;
+  return data;
+}
+
+export function createSessionTaskProjector({ sessionId } = {}) {
+  let revision = -1, previousWindow = null, tasks = new Map(), result = [], activeTurn = null, settledSteps = new Set(), previews = new Map(), finalAnswers = new Map(), dispositions = new Map();
+  const apply = entry => {
+    const event = entry.event, data = event?.data;
+    if (!event || !data) return;
+    if (event.type === 'agentkit-native/tool-outcome') {
+      const previous = tasks.get(data.turn);
+      if (event.ignorable !== true || !outcomeFact(data, data.callId, data.turn, sessionId, 'not_dispatched')
+        || !previous || previous.runId && previous.runId !== data.runId
+        || !previous.items.some(item => item.kind === 'tool' && item.callId === data.callId)) return;
+      dispositions.set(`${data.turn}:${data.callId}`, data);
+      const next = reduce(previous, { v: 1, type: 'tool.state', id: `disposition:${data.runId}:${data.callId}:${event.seq}`,
+        callId: data.callId, status: data.status });
+      tasks.set(data.turn, { ...next, runId: data.runId });return;
+    }
+    if (event.type === 'agentkit-native/context-marker') {
+      const observation = admittedContextMarker(event, sessionId), previous = observation && tasks.get(observation.turn);
+      if (!previous || previous.runId && previous.runId !== observation.runId) return;
+      const next = reduce(previous, { v: 1, type: 'context.marker',
+        id: `context:${observation.runId}:${observation.marker.id}:${observation.marker.status}`, marker: observation.marker });
+      tasks.set(observation.turn, { ...next, runId: observation.runId });
+      return;
+    }
+    if (Number.isSafeInteger(data.turn)) activeTurn = data.turn;
+    const turn = Number.isSafeInteger(data.turn) ? data.turn : activeTurn;
+    if (!Number.isSafeInteger(turn)) return;
+    let task = tasks.get(turn);
+    if (!task) task = reduce(initialState(), { v: 1, type: 'task.started', id: `turn:${turn}`, taskId: String(turn),
+      ...(event.type === 'turn/start' ? { startedAt: event.time } : {}) });
+    const prefix = `${turn}:${data.step ?? 0}`, source = `${entry.type}:${event.seq}`;
+    const responseId = typeof sessionId === 'string' && sessionId && Number.isSafeInteger(data.step) && data.step > 0
+      ? JSON.stringify([sessionId, turn, data.step]) : null;
+    // The host retains successful attempt frames until step/end so its own
+    // tool dispatcher can still resolve preview identities. A committed
+    // message already owns our transcript. Its compact content positions may
+    // differ from provider stream positions (tools can arrive before text).
+    if (event.type === 'assistant/live-chunk' && settledSteps.has(prefix)) return;
+    let index = 0;
+    const emit = (type, value) => { task = reduce(task, { v: 1, type, id: `${source}:${index++}`, ts: event.time, ...value }); };
+    if (event.type === 'turn/start' && task.taskStartedAt === null) emit('task.started', { taskId: String(turn), startedAt: event.time });
+    const block = (value, position, done = true, sourceMessageId) => {
+      const itemId = `${prefix}:block:${position}`;
+      if (value.type === 'text') emit(done ? 'text.done' : 'text.delta', { itemId, ...(responseId ? { responseId } : {}), ...(sourceMessageId ? { sourceMessageId } : {}), ...(done ? { text: value.text } : { delta: value.text }) });
+      if (value.type === 'reasoning') emit(done ? 'thinking.done' : 'thinking.delta', { itemId, ...(responseId ? { responseId } : {}), ...(sourceMessageId ? { sourceMessageId } : {}), ...(done ? { text: value.text } : { delta: value.text }) });
+    };
+    if (event.type === 'user/message' && ['user', 'user-rpc'].includes(data.source?.kind))
+      emit('text.done', { itemId: `user:${data.id ?? event.seq}`, text: textOf(data.content), role: 'user' });
+    if (event.type === 'assistant/message') {
+      const content = data.message?.content ?? [];
+      const textIndex = content.findLastIndex(part => part.type === 'text' && part.text?.trim());
+      finalAnswers.set(turn, data.interrupted !== true && textIndex >= 0 && !content.some(part => part.type === 'tool-call')
+        ? `${prefix}:block:${textIndex}` : null);
+      content.forEach((part, i) => {
+      block(part, i, true, data.message.id);
+      // A host may publish the live dispatch before the committed assistant
+      // message. Its exact call identity anchors the row after the model's
+      // preceding content; arrival order does not define transcript order.
+      if (part.type === 'tool-call' && typeof part.id === 'string') {
+        const existing = task.items.find(item => item.kind === 'tool' && item.callId === part.id);
+        if (existing) task = { ...task, items: [...task.items.filter(item => item !== existing), existing] };
+      }
+      });
+    }
+    if (event.type === 'assistant/live-chunk') {
+      const chunk = data.chunk;
+      if (chunk?.type === 'text-delta') block({ type: 'text', text: chunk.text }, chunk.index, false);
+      if (chunk?.type === 'reasoning-delta') block({ type: 'reasoning', text: chunk.text }, chunk.index, false);
+      if (chunk?.type === 'block-end') block(chunk.block, chunk.index);
+      if (chunk?.type === 'tool-call-delta') {
+        const previewId = `preview:${data.attemptId}:${chunk.index}`;
+        const previous = previews.get(previewId) ?? { text: '', receivedChars: 0, name: '' };
+        const delta = typeof chunk.argumentsDelta === 'string' ? chunk.argumentsDelta : '';
+        const next = { text: (previous.text + delta).slice(0, 128 * 1024), receivedChars: previous.receivedChars + delta.length,
+          name: chunk.name || previous.name };
+        previews.set(previewId, next);
+        emit('tool.preview', { previewId, name: next.name, input: previewToolInput(next.text), receivedChars: next.receivedChars,
+          ...(responseId ? { responseId } : {}) });
+      }
+    }
+    if (event.type === 'tool/call') {
+      let input = {}; try { input = typeof data.arguments === 'string' ? JSON.parse(data.arguments) : data.arguments; } catch { /* incomplete arguments */ }
+      emit('tool.scheduled', { callId: data.callId, name: data.name, input, ...(responseId ? { responseId } : {}) });
+    }
+    if (event.type === 'tool/result') {
+      const message = data.message;
+      const text = textOf(message?.content); let value;
+      try { value = JSON.parse(text); } catch { /* plain tool result */ }
+      const display = data.meta?.contract === 'agentkit.workspace-display/v1' ? data.meta.display
+        : commandDisplay(task.items.find(item => item.callId === message?.toolCallId)?.name, value);
+      if (dispositions.has(`${turn}:${message?.toolCallId}`)) emit('tool.state', { callId: message.toolCallId, status: 'not_dispatched' });
+      else if (uncertainFact(data.meta?.nativeOutcome, message?.toolCallId, turn, sessionId) || value?.status === 'uncertain') emit('tool.state', { callId: message?.toolCallId, status: 'uncertain', message: '执行结果未知，需要核对回执' });
+      else emit(message?.isError ? 'tool.error' : 'tool.result', { callId: message?.toolCallId,
+        ...(message?.isError ? { error: text } : { result: text,
+          ...(display ? { display } : {}) }) });
+    }
+    if (event.type === 'turn/end') {
+      const reason = data.reason;
+      const interruption = reason?.kind === 'error' && typeof reason.error?.code === 'string'
+        && Object.hasOwn(nativeInterruptionMessages, reason.error.code) ? nativeInterruptionMessages[reason.error.code] : null;
+      const outcome = interruption ? 'unverified' : reason?.kind === 'completed' ? 'unverified' : reason?.kind === 'blocked' ? 'blocked'
+        : reason?.kind === 'aborted' ? 'cancelled' : reason?.kind === 'error' ? 'failed' : 'unverified';
+      emit('task.finished', { outcome, ...(interruption ? { executionState: 'interrupted', summary: interruption }
+        : { error: reason?.error?.message }), reason: reason?.error?.code, endedAt: event.time,
+        ...(reason?.kind === 'completed' && finalAnswers.get(turn) ? { finalAnswerId: finalAnswers.get(turn) } : {}) });
+    }
+    tasks.set(turn, task);
+  };
+  return {
+    project(window) {
+      if (window.revision === revision) return result;
+      let suffix = null;
+      if (window.change?.kind === 'append' && previousWindow && window.revision > revision) {
+        if (window.revision === revision + 1) suffix = window.change.entries;
+        else {
+          // React may observe several source publications in one render. The
+          // last delta alone misses frames; replaying the whole history is
+          // unnecessary when its immutable prefix is still exactly present.
+          const previous = previousWindow.entries ?? [], next = window.entries ?? [];
+          if (next.length >= previous.length && previous.every((entry, index) => next[index] === entry))
+            suffix = next.slice(previous.length);
+        }
+      }
+      const append = suffix !== null && !suffix.some(entry => entry.event?.type === 'assistant/message');
+      if (!append) {
+        tasks = new Map(); activeTurn = null; previews = new Map(); finalAnswers = new Map(); dispositions = new Map();
+        settledSteps = new Set((window.entries ?? []).filter(entry => entry.event?.type === 'assistant/message')
+          .map(entry => `${entry.event.data.turn}:${entry.event.data.step ?? 0}`));
+      }
+      for (const entry of append ? suffix : window.entries ?? []) apply(entry);
+      revision = window.revision;previousWindow = window;
+      result = [...tasks].sort(([a], [b]) => a - b).map(([turn, state]) => ({ turn, state }));
+      return result;
+    },
+  };
+}
+
+/** Native's committed outcome overrides the transport's coarser ending. */
+export function nativeStatusForTurn(status, turn) {
+  return Number.isSafeInteger(turn) && status?.presentationTurn === turn ? status : null;
+}
+
+export function nativeTaskState(state, status, running) {
+  if (!status?.phase) return state;
+  const active = !nativeRunIsInactive(status, running);
+  let taskState = status.phase === 'completed' ? status.outcome === 'verified' ? 'completed'
+    : status.outcome === 'blocked' ? 'blocked' : 'unverified'
+    : status.phase === 'failed' ? 'failed' : status.phase === 'canceled' ? 'cancelled'
+    : status.phase === 'interrupted' || !active && !['paused', 'awaiting_interaction', 'awaiting_reconciliation'].includes(status.phase)
+        ? 'interrupted' : status.phase === 'paused' ? 'paused'
+          : ['awaiting_interaction', 'awaiting_reconciliation'].includes(status.phase) ? 'waiting' : 'running';
+  const toolStates = status.toolStates?.contract === 'agentkit.native-tool-states/v1' && status.toolStates.runId === status.runId
+    ? new Map(status.toolStates.calls.map(call => [call.callId, call.status])) : new Map();
+  const observations = status.commandPreviews;
+  const previews = status.phase === 'executing_tools' && observations?.contract === 'agentkit.native-command-previews/v1'
+    && observations.runId === status.runId && observations.sessionId === status.sessionId
+    && Array.isArray(observations.calls) && observations.calls.length <= 16
+    ? new Map(observations.calls.filter(call => typeof call.callId === 'string' && Number.isSafeInteger(call.sequence)
+      && call.sequence > 0 && call.display?.kind === 'command_preview' && typeof call.display.stdout === 'string'
+      && typeof call.display.stderr === 'string' && !Object.hasOwn(call.display, 'exit')
+      && new TextEncoder().encode(call.display.stdout + call.display.stderr).length <= 65536)
+      .map(call => [call.callId, { display: { kind: 'command_preview', stdout: call.display.stdout, stderr: call.display.stderr },
+        truncated: call.truncated === true }])) : new Map();
+  let presented = { ...state, items: state.items.map(item => item.kind === 'tool' && item.name === 'run_command'
+      && !['completed', 'failed'].includes(item.status) && previews.has(item.callId)
+      ? { ...item, status: 'running', display: previews.get(item.callId).display,
+        progress: previews.get(item.callId).truncated ? '运行中的输出预览已截断' : null } : item.kind === 'tool' && toolStates.has(item.callId)
+      ? { ...item, status: toolStates.get(item.callId) } : item.kind === 'tool-preview' && taskState !== 'running'
+      ? { ...item, streaming: false } : item.kind === 'tool' && ['scheduled', 'running'].includes(item.status)
+      && ['interrupted', 'waiting', 'paused', 'cancelled', 'failed', 'unverified', 'completed'].includes(taskState)
+      ? { ...item, status: taskState === 'waiting' ? 'waiting' : 'interrupted' } : item),
+    runId: status.runId, taskState, taskOutcome: status.outcome,
+    verificationRequired: typeof status.verificationRequired === 'boolean' ? status.verificationRequired : state.verificationRequired,
+    taskReason: status.reason, taskError: status.error?.message ?? null };
+  if (status.contextStatus?.contract === 'agentkit.native-context-status/v1' && status.contextStatus.runId === status.runId)
+    for (const marker of status.contextStatus.markers ?? []) presented = reduce(presented, {
+      v: 1, type: 'context.marker', id: `context:${status.runId}:${marker.id}:${marker.status}`, marker,
+    });
+  return presented;
+}
+
+/** Match children only by their authenticated owning tool call, never by order or role. */
+export function bindNativeSubagents(state, tasks) {
+  let next = state;
+  for (const task of tasks ?? []) {
+    if (!task.parentToolCallId || !state.items.some(item => item.kind === 'tool' && item.callId === task.parentToolCallId)) continue;
+    next = reduce(next, { v: 1, type: 'subagent.bound', id: `child:${task.childRunId}:${task.snapshotRevision}`,
+      callId: task.parentToolCallId, child: { runId: task.childRunId, sessionId: task.sessionId, parentRunId: task.parentRunId,
+        role: task.role, title: task.goalPreview, phase: task.phase, activity: task.activity } });
+  }
+  return next;
+}

package/src/host/state/native-a2a.mjs

@@ -0,0 +1,122 @@
+const check = (condition, message) => { if (!condition) throw Error(message); };
+const ended = new Set(['completed', 'failed', 'cancelled', 'rejected']);
+const paused = value => ['input_required', 'auth_required'].includes(value);
+async function observation(work, signal) {
+  let stop;
+  try {
+    signal.throwIfAborted();
+    const stopped = new Promise((resolve, reject) => {
+        stop = () => reject(signal.reason); signal.addEventListener('abort', stop, { once: true });
+        if (signal.aborted) stop();
+      });
+    const pending = new Promise(resolve => { signal.throwIfAborted(); resolve(work()); });
+    const result = await Promise.race([pending, stopped]);
+    signal.throwIfAborted(); return result;
+  } finally { signal.removeEventListener('abort', stop); }
+}
+const outcomes = new Set(['observed', 'submitted', 'already_terminal', 'remote_cancelled', 'local_cancelled_before_send', 'unknown', 'remote_task_not_bound',
+  'cancel_requested_but_remote_unknown', 'cancel_requested_but_remote_unsupported']);
+const rejectedBeforeEffect = new Set(['A2A_CONTINUATION_DEADLINE_EXCEEDED', 'A2A_CONTINUATION_NOT_ALLOWED',
+  'A2A_CONTROL_TASK_ALREADY_TERMINAL', 'A2A_CANCEL_ALREADY_REQUESTED',
+  'A2A_CONTROL_PERMISSION_DENIED', 'A2A_CONTROL_INPUT_INVALID', 'STUDIO_NATIVE_A2A_PERMISSION_UNAVAILABLE',
+  'A2A_HOST_DECISION_REQUIRED', 'A2A_HOST_DECISION_RECEIPT_INVALID', 'A2A_APPROVAL_RESPONSE_INVALID', 'A2A_APPROVAL_ALREADY_DECIDED',
+  'A2A_APPROVAL_REJECTION_NOT_ALLOWED', 'A2A_APPROVAL_REQUEST_MISSING', 'A2A_INPUT_REQUEST_MISSING',
+  'A2A_INPUT_ALREADY_DECIDED', 'A2A_STRUCTURED_INPUT_REQUIRED', 'A2A_STRUCTURED_INPUT_INVALID', 'A2A_INPUT_SCHEMA_INVALID',
+  'A2A_QUESTION_ANSWER_CONFLICT', 'A2A_QUESTION_EFFECT_ALREADY_ADMITTED']);
+
+/** An uncertain response retains the exact command. Refresh is read-only;
+ * sending a fresh prompt is never a recovery operation. */
+export function createNativeA2aTaskState({ hostRemote, task, commandId = () => globalThis.crypto.randomUUID() }) {
+  const dsh = task.ownerKind === 'dsh';
+  const keys = dsh ? ['agentId', 'sessionId', 'agentRevision', 'buildId', 'operationKey', 'callId']
+    : ['agentId', 'sessionId', 'runId', ...(task.childRunId === undefined ? [] : ['childRunId']), 'operationKey', 'callId'];
+  const identity = Object.fromEntries(keys.map(key => [key, task[key]]));
+  const child = task.childRunId === undefined ? null : { agentId: task.childAgentId, sessionId: task.childSessionId };
+  const control = dsh ? hostRemote.controlDshA2aTask : hostRemote.controlNativeA2aTask;
+  const lifetime = new AbortController(), listeners = new Set(); let disposed = false, watch;
+  let state = { task: null, loading: false, watching: false, sending: false, pending: null, outcome: '', error: '' };
+  const set = update => { if (!disposed) { state = { ...state, ...update }; for (const listener of listeners) listener(state); } };
+  const validate = value => {
+    const locator = value?.operation_locator;
+    check(value?.contract === 'agentkit.studio-a2a-task-control/v1' && (dsh
+      ? keys.every(key => locator?.[key] === identity[key]) && !['scope', 'runId', 'executionFence'].some(key => Object.hasOwn(locator, key))
+      : !child
+        ? locator?.scope?.agentId === identity.agentId && ['sessionId', 'runId', 'operationKey', 'callId'].every(key => locator[key] === identity[key])
+        : locator?.scope?.agentId === child.agentId && locator?.sessionId === child.sessionId && locator?.runId === identity.childRunId
+          && ['operationKey', 'callId'].every(key => locator[key] === identity[key]))
+      && typeof value.bindingDigest === 'string' && /^[a-f0-9]{64}$/u.test(value.bindingDigest)
+      && (!state.task || state.task.bindingDigest === value.bindingDigest)
+      && typeof value.task_id === 'string' && value.task_id.length > 0
+      && (value.remote_task_id === null || typeof value.remote_task_id === 'string')
+      && (value.remote_context_id === null || typeof value.remote_context_id === 'string')
+      && ['submitted', 'working', 'input_required', 'auth_required', ...ended].includes(value.state)
+      && outcomes.has(value.outcome) && (value.pauseDigest === null || /^[a-f0-9]{64}$/u.test(value.pauseDigest))
+      && (value.subscriptionContract === undefined || value.subscriptionContract === 'agentkit.studio-a2a-task-subscription/v1')
+      && (value.subscription === undefined || value.subscription?.contract === 'agentkit.studio-a2a-task-subscription/v1'
+        && Number.isSafeInteger(value.subscription.events) && value.subscription.events >= 0 && ['eof', 'boundary'].includes(value.subscription.ended)),
+    '远端任务回执与原调用不一致。');
+    const delivery = value.eventDelivery;
+    if (delivery !== undefined) {
+      const permanent = ['A2A_EVENT_BATCH_TOO_LARGE', 'A2A_KERNEL_FACT_INVALID', 'A2A_EVENT_REF_CAPACITY',
+        'A2A_EVENT_REF_CONFLICT', 'A2A_EVENT_REF_INVALID', 'A2A_TASK_NOT_FOUND'];
+      const fields = ['contract', 'state', 'pendingBatches', 'acknowledgedBatches', 'failedBatches', 'errorCode'];
+      check(delivery && delivery.contract === 'agentkit.a2a-event-delivery-status/v1'
+        && Object.keys(delivery).length === fields.length && Object.keys(delivery).every(key => fields.includes(key))
+        && ['pendingBatches', 'acknowledgedBatches', 'failedBatches'].every(key => Number.isSafeInteger(delivery[key]) && delivery[key] >= 0)
+        && delivery.pendingBatches + delivery.acknowledgedBatches + delivery.failedBatches <= 8192
+        && (delivery.errorCode === null || [...permanent, 'A2A_EVENT_DELIVERY_UNAVAILABLE'].includes(delivery.errorCode))
+        && delivery.state === (delivery.failedBatches ? 'failed' : delivery.errorCode ? 'retrying' : delivery.pendingBatches ? 'pending' : 'delivered')
+        && (delivery.state !== 'retrying' || delivery.pendingBatches > 0), '任务事件投递记录无效，请重新核对。');
+    }
+    return value;
+  };
+  const send = async () => {
+    if (disposed || state.sending || state.loading || !state.pending) return;
+    const pending = structuredClone(state.pending); set({ sending: true, error: '' });
+    try {
+      const result = validate(await control(pending, lifetime.signal));
+      check(result.commandId === pending.commandId, '远端任务命令回执不一致。');
+      const unknown = ['unknown', 'cancel_requested_but_remote_unknown'].includes(result.outcome);
+      set({ task: result, pending: unknown ? pending : null, outcome: result.outcome });
+    } catch (error) {
+      if (error?.code === 'A2A_CONTROL_PERMISSION_DENIED' && pending.kind === 'cancel')
+        set({ error: '本次取消未获得批准。原取消命令已保留，重新确认将再次请求批准。' });
+      else if (rejectedBeforeEffect.has(error?.code)) set({ pending: null, error: '本次操作未执行，请核对输入、权限或原任务的截止时间。' });
+      else set({ error: '操作回执尚未确认，请核对远端任务或确认原请求。' });
+    }
+    finally { set({ sending: false }); }
+  };
+  const refresh = async (kind = 'get') => {
+    if (disposed || state.loading || state.sending) return;
+    const active = kind === 'subscribe' ? new AbortController() : null;
+    watch = active; set({ loading: true, watching: Boolean(active), error: '' });
+    try {
+      const request = { ...identity, kind, commandId: commandId() };
+      const signal = active ? AbortSignal.any([lifetime.signal, active.signal]) : lifetime.signal;
+      const result = validate(await observation(() => control(request, signal), signal));
+      check(result.commandId === request.commandId, '远端任务查询回执不一致。');
+      const pending = state.pending;
+      set({ task: result, pending: pending && !ended.has(result.state)
+        && !(['continue', 'reject'].includes(pending.kind) && paused(result.state) && pending.pauseDigest !== result.pauseDigest) ? pending : null });
+    } catch (error) { if (!active?.signal.aborted) set({ error: error?.code === 'A2A_SUBSCRIPTION_UNSUPPORTED'
+      ? '远端任务未提供流式订阅，可继续核对原任务。' : '远端任务核对失败，原调用不会自动重跑。' }); }
+    finally { watch = null; set({ loading: false, watching: false }); }
+  };
+  const prepare = (kind, parts, json) => {
+    if (disposed || state.pending || state.loading || state.sending || !state.task || ended.has(state.task.state)) return;
+    if (['continue', 'reject'].includes(kind) && state.task.question?.contract === 'agentkit.a2a-question-ledger/v1'
+      && state.task.question.status !== 'pending') return;
+    if (kind === 'continue' && !paused(state.task.state)) return;
+    if (kind === 'reject' && (!paused(state.task.state) || state.task.approval?.contract !== 'agentkit.a2a-remote-approval-control/v1'
+      || state.task.approval.decision)) return;
+    set({ pending: { ...identity, kind, commandId: commandId(), ...(kind === 'continue'
+      ? { ...(json === undefined ? { parts: structuredClone(parts) } : { json }), pauseDigest: state.task.pauseDigest }
+      : kind === 'reject' ? { pauseDigest: state.task.pauseDigest } : {}) } });
+    return send();
+  };
+  return { getSnapshot: () => state, subscribe(listener) { listeners.add(listener); return () => listeners.delete(listener); },
+    refresh: () => refresh(), watch: () => refresh('subscribe'), stopWatching: () => watch?.abort(),
+    retry: send, continue: parts => prepare('continue', parts), continueJson: json => prepare('continue', undefined, json),
+    reject: () => prepare('reject'), cancel: () => prepare('cancel'),
+    dispose() { disposed = true; lifetime.abort(); listeners.clear(); } };
+}

package/src/host/state/native-child-observation.mjs

@@ -0,0 +1,35 @@
+import { initialState, reduce } from '@kingsoftcloud/agentkit-harness-ui/reducer';
+
+/** Product transport mapping. The standalone UI never calls a Native store. */
+export function nativeChildObservationState(detail) {
+  const value = detail?.observation, task = detail?.task;
+  if (value?.contract !== 'agentkit.native-child-observation/v1' || value.runId !== task?.childRunId
+    || value.sessionId !== task?.sessionId || !Array.isArray(value.rows)) throw Error('子会话过程与原任务不一致');
+  let state = initialState(), seq = 0;
+  const emit = (type, body) => { state = reduce(state, { v: 1, id: `${value.snapshotRevision}:${seq++}`, type, ...body }); };
+  emit('task.started', { taskId: value.runId, runId: value.runId });
+  if (value.prompt?.text) emit('text.done', { itemId: 'prompt', role: 'user', text: value.prompt.text });
+  for (const row of value.rows) {
+    if (row.kind === 'text' || row.kind === 'thought') emit(row.kind === 'text' ? 'text.done' : 'thinking.done', { itemId: row.id, text: row.text });
+    if (row.kind === 'tool') {
+      let input = {}; try { input = JSON.parse(row.input?.text); } catch { /* truncated preview remains an incomplete input */ }
+      emit('tool.scheduled', { callId: row.id, name: row.name, input });
+      if (row.status === 'completed') emit('tool.result', { callId: row.id, result: row.result?.text ?? null, display: row.display });
+      else if (row.status === 'failed') emit('tool.error', { callId: row.id, error: row.result?.text });
+      else if (['waiting', 'uncertain', 'interrupted'].includes(row.status)) emit('tool.state', { callId: row.id, status: row.status });
+    }
+  }
+  if (value.live?.thinking) emit('thinking.delta', { itemId: `live-thought:${value.live.operationKey}`, delta: value.live.thinking });
+  if (value.live?.text) emit('text.delta', { itemId: `live-text:${value.live.operationKey}`, delta: value.live.text });
+  if (['completed', 'failed', 'canceled'].includes(value.phase)) emit('task.finished', {
+    outcome: value.phase === 'failed' ? 'failed' : value.phase === 'canceled' ? 'cancelled' : value.outcome === 'verified' ? 'completed'
+      : value.outcome === 'blocked' ? 'blocked' : 'unverified', verificationRequired: false,
+    ...(value.phase === 'completed' && state.items.at(-1)?.kind === 'text'
+      ? { finalAnswerId: state.items.at(-1).id } : {}),
+  });
+  else if (['awaiting_interaction', 'awaiting_reconciliation', 'created'].includes(value.phase)) emit('task.state', { state: 'waiting' });
+  else if (!value.driving) emit('task.state', { state: 'interrupted' });
+  return { state, workspaceView: value.workspaceView, omittedRows: value.omittedRows, omittedChars: (value.prompt?.omittedChars ?? 0)
+    + value.rows.reduce((sum, row) => sum + (row.omittedChars ?? 0) + (row.input?.omittedChars ?? 0) + (row.result?.omittedChars ?? 0), 0)
+    + (value.live?.omittedChars ?? 0) };
+}

package/src/host/state/native-children.mjs

@@ -0,0 +1,93 @@
+const contract = 'agentkit.studio-native-child-history/v1';
+const check = (value, message) => { if (!value) throw new Error(message); };
+
+/** Own only product reads and explicit controls; execution stays in the Host. */
+export function createNativeChildrenState({ hostRemote, agentId, sessionId, commandId = () => globalThis.crypto.randomUUID() }) {
+  const identity = { agentId, sessionId }, lifetime = new AbortController(), listeners = new Set();
+  let state = { page: null, detail: null, loading: false, reading: false, pending: null, pendingAction: null, sending: false, error: '' };
+  let disposed = false, reading = 0;
+  const set = changes => { if (!disposed) { state = { ...state, ...changes }; for (const listener of listeners) listener(state); } };
+  const valid = value => check(value?.contract === contract && value.sessionId === sessionId, '子任务记录与当前会话不一致，请刷新。');
+  const validTask = task => task && ['childRunId', 'sessionId', 'parentRunId', 'role', 'phase', 'goalPreview']
+    .every(key => typeof task[key] === 'string') && typeof task.resultAvailable === 'boolean'
+    && task.usage && Number.isSafeInteger(task.usage.modelCalls) && Number.isSafeInteger(task.usage.toolCalls)
+    && (task.a2aTasks === undefined || Array.isArray(task.a2aTasks) && task.a2aTasks.length <= 10000
+      && task.a2aTasks.every(item => item?.runId === task.parentRunId && item.childRunId === task.childRunId
+        && item.childSessionId === task.sessionId && ['childAgentId', 'operationKey', 'callId']
+          .every(key => typeof item[key] === 'string' && item[key].trim() && item[key].length <= (key === 'operationKey' ? 4096 : 256))));
+  async function load(next = false) {
+    if (disposed || state.loading || next && (!state.page || state.page.complete)) return;
+    const previous = state.page;
+    set({ loading: true, error: '' });
+    try {
+      const page = await hostRemote.nativeChildHistory({ ...identity,
+        ...(next ? { offset: previous.nextOffset, inventoryDigest: previous.inventoryDigest } : {}) }, lifetime.signal);
+      if (disposed) return;
+      valid(page);
+      check(Array.isArray(page.tasks) && page.tasks.every(task => validTask(task)
+        && (!(task.canPromote || task.canCancel || task.canSendInput) || task.parentRunId === page.runId)
+        && (!task.canSendInput || Number.isSafeInteger(task.goalRevision) && task.goalRevision >= 0))
+        && new Set(page.tasks.map(task => task.childRunId)).size === page.tasks.length
+        && Number.isSafeInteger(page.offset) && page.offset >= 0 && page.nextOffset === page.offset + page.tasks.length
+        && Number.isSafeInteger(page.totalTasks) && page.totalTasks >= page.nextOffset
+        && typeof page.complete === 'boolean' && page.complete === (page.nextOffset === page.totalTasks), '子任务目录不完整，请刷新。');
+      if (next && (page.inventoryDigest !== previous.inventoryDigest || page.runId !== previous.runId || page.offset !== previous.nextOffset))
+        throw Object.assign(new Error('子任务目录已变化，请刷新。'), { code: 'child_history_inventory_changed' });
+      if (next) check(!page.tasks.some(task => previous.tasks.some(old => old.childRunId === task.childRunId)), '子任务目录重复。');
+      set({ page: next ? { ...page, tasks: [...previous.tasks, ...page.tasks] } : page });
+    } catch (error) { set({ error: error.code === 'child_history_inventory_changed' ? '子任务目录已变化，请刷新。' : '子任务读取失败，请刷新重试。' }); }
+    finally { set({ loading: false }); }
+  }
+  async function read(task, more = false) {
+    if (disposed) return;
+    const token = ++reading, previous = state.detail;
+    set({ reading: true, error: '' });
+    try {
+      const detail = await hostRemote.nativeChildResult({ ...identity, runId: task.parentRunId, childRunId: task.childRunId,
+        ...(more ? { offset: previous.nextOffset } : {}) }, lifetime.signal);
+      if (disposed || token !== reading) return;
+      valid(detail);
+      check(validTask(detail.task) && detail.task.childRunId === task.childRunId && detail.runId === task.parentRunId
+        && detail.task.parentRunId === task.parentRunId
+        && typeof detail.text === 'string' && (detail.task.resultAvailable || detail.text === '')
+        && detail.offset === (more ? previous.nextOffset : 0) && detail.nextOffset === detail.offset + [...detail.text].length
+        && Number.isSafeInteger(detail.totalChars) && detail.totalChars >= detail.nextOffset
+        && detail.complete === (detail.nextOffset === detail.totalChars), '子任务结果与请求不一致。');
+      if (more) check(previous.task.childRunId === task.childRunId && previous.resultDigest === detail.resultDigest
+        && detail.offset === previous.nextOffset, '子任务结果已变化，请重新读取。');
+      set({ detail: more ? { ...detail, text: previous.text + detail.text } : detail });
+    } catch { if (token === reading) set({ error: '子任务结果读取失败，请重新读取。' }); }
+    finally { if (token === reading) set({ reading: false }); }
+  }
+  async function sendControl() {
+    if (disposed || !state.pending || state.sending) return;
+    const pending = state.pending;
+    set({ sending: true, error: '' });
+    try {
+      const method = { promote: 'promoteNativeChild', send: 'sendNativeChildInput', cancel: 'cancelNativeChild' }[state.pendingAction];
+      const receipt = await hostRemote[method](pending, lifetime.signal);
+      check(receipt?.commandId === pending.commandId && ['accepted', 'duplicate'].includes(receipt.status), '子任务操作回执未确认。');
+      if (disposed) return;
+      set({ pending: null, pendingAction: null }); await load();
+    } catch { set({ error: '子任务操作的接收结果尚未确认。请重试原请求；不会重新启动子任务。' }); }
+    finally { set({ sending: false }); }
+  }
+  function control(action, task, extra = {}) {
+    const allowed = { promote: task.canPromote, send: task.canSendInput, cancel: task.canCancel }[action];
+    if (disposed || state.pending || !allowed || task.parentRunId !== state.page?.runId) return;
+    if (action === 'send' && (typeof extra.text !== 'string' || !extra.text.trim() || extra.text.length > 32768
+      || !Number.isSafeInteger(task.goalRevision) || task.goalRevision < 0)) return;
+    set({ pendingAction: action, pending: { ...identity, runId: task.parentRunId, childRunId: task.childRunId,
+      commandId: commandId(), ...extra } });
+    return sendControl();
+  }
+  return {
+    getSnapshot: () => state,
+    subscribe(listener) { listeners.add(listener); return () => listeners.delete(listener); },
+    refresh: () => load(), next: () => load(true), read,
+    promote: task => control('promote', task), cancel: task => control('cancel', task),
+    sendInput: (task, text) => control('send', task, { text, expectedGoalRevision: task.goalRevision }),
+    retryControl: sendControl, retryPromotion: sendControl,
+    dispose() { if (disposed) return; disposed = true; lifetime.abort(); reading++; listeners.clear(); },
+  };
+}

package/src/host/state/native-outcome.mjs

@@ -0,0 +1,35 @@
+const phases = { created: '已准备', preparing_context: '整理上下文', requesting_model: '正在生成回复',
+  compacting: '压缩上下文', verifying: '验证结果', executing_tools: '执行工具', awaiting_interaction: '等待审批或输入', paused: '已暂停',
+  awaiting_reconciliation: '等待核对执行结果', reconciling_tool: '正在核对执行结果', interrupted: '执行中断，需要核对', finalizing: '收尾中' };
+
+/** The committed phase survives a crash; only the owner control state says work is still being driven. */
+export function nativeRunIsInactive(status, transportRunning = true) {
+  return status?.state ? status.state !== 'recovering' : !transportRunning;
+}
+
+/** Execution phase and task evidence are separate facts. No inferred success. */
+export function nativeRunPresentation(status) {
+  if (!status?.runId || !status.phase) return null;
+  if (status.phase === 'interrupted' && status.reason === 'effect_outcome_unknown'
+    && status.backgroundInterruptionReview?.contract === 'agentkit.background-interruption-review/v1'
+    && status.backgroundInterruptionReview.confirmedStopped === true && status.state === 'closed')
+    return { label: '已结束等待，原结果未知', detail: '已核对原操作停止并关闭本轮；未知结果与原回执保持不变，没有重跑原命令。' };
+  if (status.phase === 'canceled') return { label: '已取消', detail: '本轮执行已停止；已经发生的文件或外部修改不会因此自动撤销。' };
+  if (status.outcome === 'blocked') return { label: '任务受阻', detail: status.error?.message || '本轮未能完成任务。请查看回复中的缺项，检查 Agent 的「绑定能力」及审批要求。' };
+  if (status.phase === 'failed') return { label: '执行失败', detail: status.error?.message || '本轮执行未成功，请查看错误并核对结果后重试。' };
+  if (status.phase === 'interrupted' && status.reason === 'effect_outcome_unknown')
+    return { label: '执行中断，结果待核对', detail: '原操作结果尚未确认。请在运行与子任务中核对处置方式；不会自动重跑原操作。' };
+  if (nativeRunIsInactive(status) && !['completed', 'paused', 'awaiting_interaction', 'awaiting_reconciliation'].includes(status.phase))
+    return status.canResume === true
+      ? { label: '执行中断，等待恢复', detail: '原运行已没有活动执行者；恢复原任务后才会继续。已提交的回执保持不变。' }
+      : { label: '任务已中断', detail: status.error?.message || '原运行已停止。请查看运行记录和当前可用操作。' };
+  if (status.phase !== 'completed') return { label: phases[status.phase] || '处理中', detail: '' };
+  if (status.outcome === 'failed' || status.outcome === 'budget_exhausted') return { label: '任务未完成', detail: '本轮已结束，任务未完成。请查看错误、预算和结果记录。' };
+  if (status.outcome === 'verified') return { label: '任务已验证', detail: '任务已通过本次配置的验证检查；验证范围以结果证据为准。' };
+  if (status.outcome === 'partial' && status.reason === 'required_verification_incomplete')
+    return { label: '部分已验证', detail: '部分检查已通过，其余任务要求尚未获得验证证据；请核对回复和实际结果。' };
+  if (status.outcome === 'partial') return { label: '部分完成', detail: '部分要求已有通过证据，整体结果仍需核对；请查看回复及结果。' };
+  if (status.verificationRequired === true || status.verificationRequired !== false && status.reason === 'required_verification_incomplete')
+    return { label: '本轮已结束 · 结果未验证', detail: '本任务配置了必需的验证检查，目前尚无全部通过的证据。' };
+  return { label: '本轮已结束', detail: '本轮执行已结束，已返回回复。' };
+}