feat: add tiered channel agent and mobile Codex bridge
This commit is contained in:
parent
950b7e48b3
commit
71db11e7e8
35 changed files with 2242 additions and 76 deletions
|
|
@ -162,6 +162,7 @@ fn expected_account_for_human_number(number: &str) -> Option<&'static str> {
|
|||
"TCS-GL-0007∞" => Some("feimao"),
|
||||
"TCS-GL-0008∞" => Some("juzi"),
|
||||
"TCS-GL-0016∞" => Some("awen"),
|
||||
"TCS-CL-0009" => Some("canger"),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -196,6 +196,20 @@ static ARTIFACTS: &[BundledArtifact] = &[
|
|||
"FIFTH_DOMAIN",
|
||||
"bca318d02ed0b214c1d9a3b97a93a8785b1c85488516cae0e03644bcdf0819a7"
|
||||
),
|
||||
artifact!(
|
||||
"fifth-domain/EED-AFFECTIVE-SELF-KERNEL-0001.json",
|
||||
"PERSONA_KERNEL",
|
||||
"ICE_BB_0004",
|
||||
"CANGER_BOTTLE_CHANNEL",
|
||||
"701d96c53f2c2c2f061033fc08ff15e1ea451356853f2a27ad6b92cce25eda2e"
|
||||
),
|
||||
artifact!(
|
||||
"fifth-domain/EED-HLDP-MEMORY-v1.json",
|
||||
"PERSONA_MEMORY",
|
||||
"ICE_BB_0004",
|
||||
"CANGER_BOTTLE_CHANNEL",
|
||||
"3ac404bb38232987a4c0bc896e06d171833023ab1b5af65d4e00216de4029f42"
|
||||
),
|
||||
];
|
||||
|
||||
#[derive(Clone, Debug, Serialize)]
|
||||
|
|
@ -263,7 +277,7 @@ pub fn ensure_for_audience(
|
|||
let mut installed = Vec::new();
|
||||
for artifact in ARTIFACTS
|
||||
.iter()
|
||||
.filter(|artifact| applies(artifact.scope, audience))
|
||||
.filter(|artifact| artifact_applies(artifact, audience, channel_number))
|
||||
{
|
||||
let bundled_hash = sha256(artifact.bytes);
|
||||
if bundled_hash != artifact.expected_sha256 {
|
||||
|
|
@ -332,6 +346,15 @@ fn applies(scope: &str, audience: &str) -> bool {
|
|||
|| (scope == "FIFTH_DOMAIN" && audience == "FIFTH_DOMAIN_PRIVATE_INSTANCE")
|
||||
}
|
||||
|
||||
fn artifact_applies(artifact: &BundledArtifact, audience: &str, channel_number: &str) -> bool {
|
||||
if channel_number == "SYS-GLW-PTS-0001" {
|
||||
return artifact.scope == "COMMON"
|
||||
|| artifact.scope == "CANGER_BOTTLE_CHANNEL"
|
||||
|| (artifact.kind == "PERSONA_ENVIRONMENT" && artifact.subject == "BOTTLE_CENTRAL");
|
||||
}
|
||||
applies(artifact.scope, audience)
|
||||
}
|
||||
|
||||
fn installation_root(app: &AppHandle, channel_number: &str) -> Result<PathBuf, String> {
|
||||
let account = crate::authenticated_storage::account_storage_root(app, "language-kernels-v1")?;
|
||||
Ok(account.join(sha256(channel_number.as_bytes())))
|
||||
|
|
@ -406,6 +429,33 @@ mod tests {
|
|||
assert_eq!(ordinary, 6);
|
||||
assert_eq!(team, 10);
|
||||
assert_eq!(fifth, 19);
|
||||
let canger = ARTIFACTS
|
||||
.iter()
|
||||
.filter(|artifact| {
|
||||
artifact_applies(
|
||||
artifact,
|
||||
"FIFTH_DOMAIN_PRIVATE_INSTANCE",
|
||||
"SYS-GLW-PTS-0001",
|
||||
)
|
||||
})
|
||||
.count();
|
||||
assert_eq!(canger, 9);
|
||||
assert!(ARTIFACTS.iter().any(|artifact| {
|
||||
artifact.subject == "ICE_BB_0004"
|
||||
&& artifact_applies(
|
||||
artifact,
|
||||
"FIFTH_DOMAIN_PRIVATE_INSTANCE",
|
||||
"SYS-GLW-PTS-0001",
|
||||
)
|
||||
}));
|
||||
assert!(!ARTIFACTS.iter().any(|artifact| {
|
||||
artifact.subject == "ICE_P_ZY001"
|
||||
&& artifact_applies(
|
||||
artifact,
|
||||
"FIFTH_DOMAIN_PRIVATE_INSTANCE",
|
||||
"SYS-GLW-PTS-0001",
|
||||
)
|
||||
}));
|
||||
assert!(!applies("FIFTH_DOMAIN", "ORDINARY_USER_INITIAL_CHANNEL"));
|
||||
assert!(!applies("TEAM", "FIFTH_DOMAIN_PRIVATE_INSTANCE"));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -433,6 +433,11 @@ fn deterministic_route(objective: &str) -> Option<(&'static str, Value, &'static
|
|||
None
|
||||
}
|
||||
|
||||
pub(crate) fn deterministic_tool_route(objective: &str) -> Option<(String, Value, &'static str)> {
|
||||
deterministic_route(objective)
|
||||
.map(|(tool_number, arguments, reason)| (tool_number.into(), arguments, reason))
|
||||
}
|
||||
|
||||
async fn local_model_route(
|
||||
_app: &AppHandle,
|
||||
config: &LocalBrainConfig,
|
||||
|
|
|
|||
|
|
@ -9,12 +9,13 @@ use serde::{Deserialize, Serialize};
|
|||
use std::{
|
||||
collections::HashMap,
|
||||
fs,
|
||||
io::{Read, Write},
|
||||
io::{BufRead, BufReader, Read, Write},
|
||||
net::{Shutdown, TcpListener, TcpStream, UdpSocket},
|
||||
path::{Path, PathBuf},
|
||||
process::{Child, ChildStdin, Command, Stdio},
|
||||
sync::{
|
||||
atomic::{AtomicBool, AtomicUsize, Ordering},
|
||||
Arc, Mutex,
|
||||
mpsc, Arc, Mutex,
|
||||
},
|
||||
thread,
|
||||
time::{Duration, SystemTime, UNIX_EPOCH},
|
||||
|
|
@ -57,6 +58,7 @@ impl Drop for MobileSyncHandle {
|
|||
}
|
||||
|
||||
struct MobileSyncRuntime {
|
||||
app: Option<AppHandle>,
|
||||
shutdown: AtomicBool,
|
||||
active_connections: AtomicUsize,
|
||||
port: u16,
|
||||
|
|
@ -130,6 +132,7 @@ struct SyncRequest {
|
|||
counter: u64,
|
||||
after_cursor: Option<u64>,
|
||||
capture: Option<MobileCaptureInput>,
|
||||
agent_message: Option<MobileAgentMessageInput>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Deserialize)]
|
||||
|
|
@ -140,6 +143,16 @@ struct MobileCaptureInput {
|
|||
request_id: String,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Deserialize)]
|
||||
#[serde(rename_all = "camelCase", deny_unknown_fields)]
|
||||
struct MobileAgentMessageInput {
|
||||
destination: Option<String>,
|
||||
codex_thread_id: Option<String>,
|
||||
conversation_id: Option<String>,
|
||||
content: String,
|
||||
request_id: String,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Serialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct MobileSyncSnapshot {
|
||||
|
|
@ -153,9 +166,27 @@ pub struct MobileSyncSnapshot {
|
|||
web_novel: MobileWebNovelProjection,
|
||||
education: MobileEducationProjection,
|
||||
recent_captures: Vec<MobileCaptureProjection>,
|
||||
agent_exchange: Option<MobileAgentExchangeProjection>,
|
||||
recent_agent_exchanges: Vec<MobileAgentExchangeProjection>,
|
||||
codex_target: Option<CodexThreadSummary>,
|
||||
boundary: MobileBoundaryProjection,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Deserialize, Serialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
struct MobileAgentExchangeProjection {
|
||||
request_id: String,
|
||||
conversation_id: String,
|
||||
state: String,
|
||||
state_version: u64,
|
||||
reply: String,
|
||||
responder_number: String,
|
||||
responder_name: String,
|
||||
responder_kind: String,
|
||||
persona_binding_state: String,
|
||||
tool_receipts: Vec<crate::persona_agent_runtime::AgentToolReceipt>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Serialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
struct MobileChannelProjection {
|
||||
|
|
@ -212,6 +243,32 @@ struct MobileBoundaryProjection {
|
|||
model_api: &'static str,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Deserialize, Serialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct CodexThreadSummary {
|
||||
thread_id: String,
|
||||
name: String,
|
||||
preview: String,
|
||||
cwd: String,
|
||||
updated_at_unix_seconds: u64,
|
||||
status: String,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Serialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct CodexThreadListSnapshot {
|
||||
schema: &'static str,
|
||||
state: &'static str,
|
||||
cli_version: String,
|
||||
threads: Vec<CodexThreadSummary>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Deserialize)]
|
||||
#[serde(rename_all = "camelCase", deny_unknown_fields)]
|
||||
pub struct SelectMobileCodexThreadInput {
|
||||
thread_id: String,
|
||||
}
|
||||
|
||||
struct HttpRequest {
|
||||
method: String,
|
||||
path: String,
|
||||
|
|
@ -259,6 +316,7 @@ pub fn start_mobile_sync(app: AppHandle) -> Result<MobileSyncStatus, String> {
|
|||
.map_err(|error| format!("HOLOLAKE_MOBILE_SYNC_ADDRESS_FAILED: {error}"))?
|
||||
.port();
|
||||
let runtime = Arc::new(MobileSyncRuntime {
|
||||
app: Some(app.clone()),
|
||||
shutdown: AtomicBool::new(false),
|
||||
active_connections: AtomicUsize::new(0),
|
||||
port,
|
||||
|
|
@ -364,7 +422,42 @@ pub fn get_mobile_sync_snapshot(app: AppHandle) -> Result<MobileSyncSnapshot, St
|
|||
let handle = guard
|
||||
.as_ref()
|
||||
.ok_or_else(|| "HOLOLAKE_MOBILE_SYNC_NOT_RUNNING".to_string())?;
|
||||
build_snapshot(&handle.runtime)
|
||||
build_snapshot(&handle.runtime, None)
|
||||
}
|
||||
|
||||
pub fn list_mobile_codex_threads(app: AppHandle) -> Result<CodexThreadListSnapshot, String> {
|
||||
require_active(&app)?;
|
||||
list_codex_threads()
|
||||
}
|
||||
|
||||
pub fn select_mobile_codex_thread(
|
||||
app: AppHandle,
|
||||
input: SelectMobileCodexThreadInput,
|
||||
) -> Result<MobileSyncSnapshot, String> {
|
||||
require_active(&app)?;
|
||||
validate_id(&input.thread_id)?;
|
||||
let listed = list_codex_threads()?;
|
||||
let selected = listed
|
||||
.threads
|
||||
.into_iter()
|
||||
.find(|thread| thread.thread_id == input.thread_id)
|
||||
.ok_or_else(|| "CODEX_THREAD_NOT_FOUND".to_string())?;
|
||||
let state = app.state::<MobileSyncState>();
|
||||
let guard = state
|
||||
.handle
|
||||
.lock()
|
||||
.map_err(|_| "HOLOLAKE_MOBILE_SYNC_STATE_LOCK_FAILED".to_string())?;
|
||||
let handle = guard
|
||||
.as_ref()
|
||||
.ok_or_else(|| "HOLOLAKE_MOBILE_SYNC_NOT_RUNNING".to_string())?;
|
||||
let connection = open_database(&handle.runtime.database_path)?;
|
||||
connection
|
||||
.execute(
|
||||
"INSERT INTO mobile_codex_target (singleton, thread_id, thread_name, preview, cwd, updated_at_unix_seconds, selected_at_unix_ms) VALUES (1, ?1, ?2, ?3, ?4, ?5, ?6) ON CONFLICT(singleton) DO UPDATE SET thread_id=excluded.thread_id, thread_name=excluded.thread_name, preview=excluded.preview, cwd=excluded.cwd, updated_at_unix_seconds=excluded.updated_at_unix_seconds, selected_at_unix_ms=excluded.selected_at_unix_ms",
|
||||
params![selected.thread_id, selected.name, selected.preview, selected.cwd, selected.updated_at_unix_seconds, now_unix_ms()],
|
||||
)
|
||||
.map_err(database_error)?;
|
||||
build_snapshot(&handle.runtime, None)
|
||||
}
|
||||
|
||||
fn status_from_handle(handle: Option<&MobileSyncHandle>) -> Result<MobileSyncStatus, String> {
|
||||
|
|
@ -567,6 +660,11 @@ fn sync_device(runtime: &MobileSyncRuntime, request: &HttpRequest) -> Result<Htt
|
|||
)
|
||||
.map_err(database_error)?;
|
||||
}
|
||||
let agent_request = input.agent_message;
|
||||
let cached_agent_exchange = match agent_request.as_ref() {
|
||||
Some(message) => prepare_agent_request(&transaction, device_id, message)?,
|
||||
None => None,
|
||||
};
|
||||
transaction
|
||||
.execute(
|
||||
"UPDATE mobile_devices SET last_counter = ?2, last_seen_at_unix_ms = ?3 WHERE device_id = ?1 AND revoked = 0",
|
||||
|
|
@ -574,14 +672,28 @@ fn sync_device(runtime: &MobileSyncRuntime, request: &HttpRequest) -> Result<Htt
|
|||
)
|
||||
.map_err(database_error)?;
|
||||
transaction.commit().map_err(database_error)?;
|
||||
let mut snapshot = build_snapshot(runtime)?;
|
||||
let agent_exchange = match (agent_request, cached_agent_exchange) {
|
||||
(_, Some(exchange)) => Some(exchange),
|
||||
(Some(message), None) => match execute_agent_request(runtime, device_id, &message) {
|
||||
Ok(exchange) => Some(exchange),
|
||||
Err(error) => {
|
||||
mark_agent_request_failed(runtime, device_id, &message.request_id)?;
|
||||
return Err(error);
|
||||
}
|
||||
},
|
||||
(None, None) => None,
|
||||
};
|
||||
let mut snapshot = build_snapshot(runtime, agent_exchange)?;
|
||||
if let Some(after) = input.after_cursor {
|
||||
snapshot.recent_captures.retain(|item| item.cursor > after);
|
||||
}
|
||||
encrypted_response(&key, aad.as_bytes(), &snapshot)
|
||||
}
|
||||
|
||||
fn build_snapshot(runtime: &MobileSyncRuntime) -> Result<MobileSyncSnapshot, String> {
|
||||
fn build_snapshot(
|
||||
runtime: &MobileSyncRuntime,
|
||||
agent_exchange: Option<MobileAgentExchangeProjection>,
|
||||
) -> Result<MobileSyncSnapshot, String> {
|
||||
let captures = list_captures(&runtime.database_path)?;
|
||||
let cursor = captures.first().map(|item| item.cursor).unwrap_or(0);
|
||||
let growth_event_count = count_rows(
|
||||
|
|
@ -606,16 +718,211 @@ fn build_snapshot(runtime: &MobileSyncRuntime) -> Result<MobileSyncSnapshot, Str
|
|||
web_novel: web_novel_projection(&runtime.account_root),
|
||||
education: education_projection(&runtime.account_root),
|
||||
recent_captures: captures,
|
||||
agent_exchange,
|
||||
recent_agent_exchanges: list_agent_exchanges(&runtime.database_path)?,
|
||||
codex_target: read_codex_target(&runtime.database_path)?,
|
||||
boundary: MobileBoundaryProjection {
|
||||
mobile_role: "REMOTE_BODY_ENTRY_OF_THE_SAME_PERSONA_SYSTEM",
|
||||
remote_desktop_clone: false,
|
||||
desktop_offline_execution: false,
|
||||
sensitive_education_values: "NEVER_INCLUDED_IN_MOBILE_SUMMARY",
|
||||
model_api: "NOT_CONFIGURED_LOCAL_PROJECTION_ONLY",
|
||||
model_api: "DESKTOP_AGENT_RUNTIME_ONLY",
|
||||
},
|
||||
})
|
||||
}
|
||||
|
||||
fn prepare_agent_request(
|
||||
transaction: &rusqlite::Transaction<'_>,
|
||||
device_id: &str,
|
||||
input: &MobileAgentMessageInput,
|
||||
) -> Result<Option<MobileAgentExchangeProjection>, String> {
|
||||
validate_agent_message(input)?;
|
||||
let digest_material = format!(
|
||||
"{}\n{}\n{}",
|
||||
agent_destination(input)?,
|
||||
input.codex_thread_id.as_deref().unwrap_or(""),
|
||||
input.content.trim()
|
||||
);
|
||||
let digest = ring::digest::digest(&ring::digest::SHA256, digest_material.as_bytes());
|
||||
let content_sha256 = hex_bytes(digest.as_ref());
|
||||
let existing: Option<(String, String, String, Option<String>)> = transaction
|
||||
.query_row(
|
||||
"SELECT source_device_id, content_sha256, state, response_json FROM mobile_agent_requests WHERE request_id = ?1",
|
||||
params![input.request_id],
|
||||
|row| Ok((row.get(0)?, row.get(1)?, row.get(2)?, row.get(3)?)),
|
||||
)
|
||||
.optional()
|
||||
.map_err(database_error)?;
|
||||
if let Some((source_device_id, existing_sha256, state, response_json)) = existing {
|
||||
if source_device_id != device_id || existing_sha256 != content_sha256 {
|
||||
return Err("AGENT_REQUEST_ID_CONFLICT".into());
|
||||
}
|
||||
if state == "PENDING" {
|
||||
return Err("AGENT_REQUEST_IN_PROGRESS".into());
|
||||
}
|
||||
if state == "COMPLETED" {
|
||||
let value = response_json.ok_or_else(|| "AGENT_RESPONSE_CACHE_INVALID".to_string())?;
|
||||
return serde_json::from_str(&value)
|
||||
.map(Some)
|
||||
.map_err(|_| "AGENT_RESPONSE_CACHE_INVALID".to_string());
|
||||
}
|
||||
transaction
|
||||
.execute(
|
||||
"UPDATE mobile_agent_requests SET state = 'PENDING', response_json = NULL, completed_at_unix_ms = NULL WHERE request_id = ?1",
|
||||
params![input.request_id],
|
||||
)
|
||||
.map_err(database_error)?;
|
||||
return Ok(None);
|
||||
}
|
||||
transaction
|
||||
.execute(
|
||||
"INSERT INTO mobile_agent_requests (request_id, source_device_id, conversation_id, content_sha256, state, response_json, created_at_unix_ms, completed_at_unix_ms) VALUES (?1, ?2, ?3, ?4, 'PENDING', NULL, ?5, NULL)",
|
||||
params![input.request_id, device_id, input.conversation_id, content_sha256, now_unix_ms()],
|
||||
)
|
||||
.map_err(database_error)?;
|
||||
Ok(None)
|
||||
}
|
||||
|
||||
fn execute_agent_request(
|
||||
runtime: &MobileSyncRuntime,
|
||||
device_id: &str,
|
||||
input: &MobileAgentMessageInput,
|
||||
) -> Result<MobileAgentExchangeProjection, String> {
|
||||
if agent_destination(input)? == "CODEX_SELECTED_THREAD" {
|
||||
return execute_codex_agent_request(runtime, device_id, input);
|
||||
}
|
||||
let app = runtime
|
||||
.app
|
||||
.as_ref()
|
||||
.ok_or_else(|| "AGENT_RUNTIME_NOT_AVAILABLE".to_string())?
|
||||
.clone();
|
||||
let result = tauri::async_runtime::block_on(crate::persona_agent_runtime::send_message(
|
||||
app,
|
||||
crate::persona_agent_runtime::SendAgentMessageInput {
|
||||
conversation_id: input.conversation_id.clone(),
|
||||
provider_id: "bailian-token-plan".into(),
|
||||
model: None,
|
||||
content: input.content.trim().into(),
|
||||
active_knowledge_path: None,
|
||||
},
|
||||
));
|
||||
let exchange = match result {
|
||||
Ok(conversation) => {
|
||||
let reply = conversation
|
||||
.messages
|
||||
.last()
|
||||
.ok_or_else(|| "AGENT_RESPONSE_EMPTY".to_string())?;
|
||||
MobileAgentExchangeProjection {
|
||||
request_id: input.request_id.clone(),
|
||||
conversation_id: conversation.conversation_id,
|
||||
state: "COMPLETED".into(),
|
||||
state_version: conversation.state_version,
|
||||
reply: reply.content.clone(),
|
||||
responder_number: reply.participant_number.clone(),
|
||||
responder_name: reply.participant_name.clone(),
|
||||
responder_kind: reply.role.clone(),
|
||||
persona_binding_state: if reply.role == "persona" {
|
||||
"BOUND_VERIFY_PASS".into()
|
||||
} else {
|
||||
"UNBOUND_CHANNEL_SYSTEM_RESPONSE".into()
|
||||
},
|
||||
tool_receipts: reply.tool_receipts.clone(),
|
||||
}
|
||||
}
|
||||
Err(error) => {
|
||||
let connection = open_database(&runtime.database_path)?;
|
||||
connection
|
||||
.execute(
|
||||
"UPDATE mobile_agent_requests SET state = 'FAILED', completed_at_unix_ms = ?2 WHERE request_id = ?1 AND source_device_id = ?3",
|
||||
params![input.request_id, now_unix_ms(), device_id],
|
||||
)
|
||||
.map_err(database_error)?;
|
||||
return Err(format!("AGENT_REQUEST_FAILED:{error}"));
|
||||
}
|
||||
};
|
||||
let response_json = serde_json::to_string(&exchange)
|
||||
.map_err(|error| format!("AGENT_RESPONSE_ENCODE_FAILED:{error}"))?;
|
||||
let connection = open_database(&runtime.database_path)?;
|
||||
connection
|
||||
.execute(
|
||||
"UPDATE mobile_agent_requests SET conversation_id = ?2, state = 'COMPLETED', response_json = ?3, completed_at_unix_ms = ?4 WHERE request_id = ?1 AND source_device_id = ?5",
|
||||
params![input.request_id, exchange.conversation_id, response_json, now_unix_ms(), device_id],
|
||||
)
|
||||
.map_err(database_error)?;
|
||||
Ok(exchange)
|
||||
}
|
||||
|
||||
fn execute_codex_agent_request(
|
||||
runtime: &MobileSyncRuntime,
|
||||
device_id: &str,
|
||||
input: &MobileAgentMessageInput,
|
||||
) -> Result<MobileAgentExchangeProjection, String> {
|
||||
let selected = read_codex_target(&runtime.database_path)?
|
||||
.ok_or_else(|| "CODEX_THREAD_NOT_SELECTED".to_string())?;
|
||||
let requested_thread_id = input
|
||||
.codex_thread_id
|
||||
.as_deref()
|
||||
.ok_or_else(|| "CODEX_THREAD_ID_REQUIRED".to_string())?;
|
||||
if requested_thread_id != selected.thread_id {
|
||||
return Err("CODEX_THREAD_SELECTION_CHANGED".into());
|
||||
}
|
||||
let result = execute_codex_read_only_turn(
|
||||
requested_thread_id,
|
||||
&selected.cwd,
|
||||
device_id,
|
||||
input.content.trim(),
|
||||
);
|
||||
let exchange = match result {
|
||||
Ok(reply) => MobileAgentExchangeProjection {
|
||||
request_id: input.request_id.clone(),
|
||||
conversation_id: requested_thread_id.to_string(),
|
||||
state: "COMPLETED".into(),
|
||||
state_version: now_unix_ms(),
|
||||
reply,
|
||||
responder_number: "CODEX-APP-SERVER-LOCAL".into(),
|
||||
responder_name: selected.name,
|
||||
responder_kind: "codex_read_only_task".into(),
|
||||
persona_binding_state: "CODEX_HOST_NOT_PERSONA_BINDING".into(),
|
||||
tool_receipts: Vec::new(),
|
||||
},
|
||||
Err(error) => return Err(format!("CODEX_REQUEST_FAILED:{error}")),
|
||||
};
|
||||
complete_agent_request(runtime, device_id, &exchange)?;
|
||||
Ok(exchange)
|
||||
}
|
||||
|
||||
fn mark_agent_request_failed(
|
||||
runtime: &MobileSyncRuntime,
|
||||
device_id: &str,
|
||||
request_id: &str,
|
||||
) -> Result<(), String> {
|
||||
let connection = open_database(&runtime.database_path)?;
|
||||
connection
|
||||
.execute(
|
||||
"UPDATE mobile_agent_requests SET state = 'FAILED', completed_at_unix_ms = ?2 WHERE request_id = ?1 AND source_device_id = ?3",
|
||||
params![request_id, now_unix_ms(), device_id],
|
||||
)
|
||||
.map_err(database_error)?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn complete_agent_request(
|
||||
runtime: &MobileSyncRuntime,
|
||||
device_id: &str,
|
||||
exchange: &MobileAgentExchangeProjection,
|
||||
) -> Result<(), String> {
|
||||
let response_json = serde_json::to_string(exchange)
|
||||
.map_err(|error| format!("AGENT_RESPONSE_ENCODE_FAILED:{error}"))?;
|
||||
let connection = open_database(&runtime.database_path)?;
|
||||
connection
|
||||
.execute(
|
||||
"UPDATE mobile_agent_requests SET conversation_id = ?2, state = 'COMPLETED', response_json = ?3, completed_at_unix_ms = ?4 WHERE request_id = ?1 AND source_device_id = ?5",
|
||||
params![exchange.request_id, exchange.conversation_id, response_json, now_unix_ms(), device_id],
|
||||
)
|
||||
.map_err(database_error)?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn web_novel_projection(account_root: &Path) -> MobileWebNovelProjection {
|
||||
let path = account_root.join("web-novel-workspace-v1/web-novel-workspace.sqlite3");
|
||||
let Ok(connection) =
|
||||
|
|
@ -737,6 +1044,311 @@ fn list_captures(path: &Path) -> Result<Vec<MobileCaptureProjection>, String> {
|
|||
Ok(captures)
|
||||
}
|
||||
|
||||
fn list_agent_exchanges(path: &Path) -> Result<Vec<MobileAgentExchangeProjection>, String> {
|
||||
let connection = open_database(path)?;
|
||||
let mut statement = connection
|
||||
.prepare(
|
||||
"SELECT response_json FROM mobile_agent_requests WHERE state = 'COMPLETED' AND response_json IS NOT NULL ORDER BY completed_at_unix_ms DESC LIMIT 20",
|
||||
)
|
||||
.map_err(database_error)?;
|
||||
let rows = statement
|
||||
.query_map([], |row| row.get::<_, String>(0))
|
||||
.map_err(database_error)?;
|
||||
let mut exchanges = Vec::new();
|
||||
for row in rows {
|
||||
let value = row.map_err(database_error)?;
|
||||
exchanges.push(
|
||||
serde_json::from_str(&value).map_err(|_| "AGENT_RESPONSE_CACHE_INVALID".to_string())?,
|
||||
);
|
||||
}
|
||||
Ok(exchanges)
|
||||
}
|
||||
|
||||
fn read_codex_target(path: &Path) -> Result<Option<CodexThreadSummary>, String> {
|
||||
let connection = open_database(path)?;
|
||||
connection
|
||||
.query_row(
|
||||
"SELECT thread_id, thread_name, preview, cwd, updated_at_unix_seconds FROM mobile_codex_target WHERE singleton = 1",
|
||||
[],
|
||||
|row| {
|
||||
Ok(CodexThreadSummary {
|
||||
thread_id: row.get(0)?,
|
||||
name: row.get(1)?,
|
||||
preview: row.get(2)?,
|
||||
cwd: row.get(3)?,
|
||||
updated_at_unix_seconds: row.get(4)?,
|
||||
status: "SELECTED_FOR_MOBILE_READ_ONLY".into(),
|
||||
})
|
||||
},
|
||||
)
|
||||
.optional()
|
||||
.map_err(database_error)
|
||||
}
|
||||
|
||||
fn list_codex_threads() -> Result<CodexThreadListSnapshot, String> {
|
||||
let (mut child, mut stdin, receiver) = start_codex_app_server()?;
|
||||
let result = (|| {
|
||||
let initialize = initialize_codex_app_server(&mut stdin, &receiver)?;
|
||||
write_codex_rpc(
|
||||
&mut stdin,
|
||||
&serde_json::json!({"method": "thread/list", "id": 1, "params": {"limit": 50}}),
|
||||
)?;
|
||||
let response = receive_codex_response(&receiver, 1, Duration::from_secs(8))?;
|
||||
Ok::<_, String>((initialize, response))
|
||||
})();
|
||||
let _ = child.kill();
|
||||
let _ = child.wait();
|
||||
let (initialize, response) = result?;
|
||||
let cli_version = initialize
|
||||
.pointer("/result/userAgent")
|
||||
.and_then(|value| value.as_str())
|
||||
.unwrap_or("Codex")
|
||||
.to_string();
|
||||
let data = response
|
||||
.pointer("/result/data")
|
||||
.and_then(|value| value.as_array())
|
||||
.ok_or_else(|| "CODEX_THREAD_LIST_INVALID".to_string())?;
|
||||
let threads = data
|
||||
.iter()
|
||||
.filter_map(|value| {
|
||||
let thread_id = value.get("id")?.as_str()?.to_string();
|
||||
let cwd = value.get("cwd")?.as_str()?.to_string();
|
||||
let name = value
|
||||
.get("name")
|
||||
.and_then(|item| item.as_str())
|
||||
.unwrap_or("未命名 Codex 任务")
|
||||
.to_string();
|
||||
let preview = value
|
||||
.get("preview")
|
||||
.and_then(|item| item.as_str())
|
||||
.unwrap_or("")
|
||||
.to_string();
|
||||
let updated_at_unix_seconds = value
|
||||
.get("updatedAt")
|
||||
.and_then(|item| item.as_u64())
|
||||
.unwrap_or(0);
|
||||
let status = value
|
||||
.pointer("/status/type")
|
||||
.and_then(|item| item.as_str())
|
||||
.unwrap_or("unknown")
|
||||
.to_string();
|
||||
Some(CodexThreadSummary {
|
||||
thread_id,
|
||||
name,
|
||||
preview,
|
||||
cwd,
|
||||
updated_at_unix_seconds,
|
||||
status,
|
||||
})
|
||||
})
|
||||
.collect();
|
||||
Ok(CodexThreadListSnapshot {
|
||||
schema: "hololake.codex-app-server-thread-list/v1",
|
||||
state: "READ_ONLY_THREAD_DISCOVERY",
|
||||
cli_version,
|
||||
threads,
|
||||
})
|
||||
}
|
||||
|
||||
fn initialize_codex_app_server(
|
||||
stdin: &mut ChildStdin,
|
||||
receiver: &mpsc::Receiver<serde_json::Value>,
|
||||
) -> Result<serde_json::Value, String> {
|
||||
write_codex_rpc(
|
||||
stdin,
|
||||
&serde_json::json!({
|
||||
"method": "initialize",
|
||||
"id": 0,
|
||||
"params": {"clientInfo": {"name": "hololake", "title": "HoloLake", "version": "0.5.0"}}
|
||||
}),
|
||||
)?;
|
||||
let initialize = receive_codex_response(receiver, 0, Duration::from_secs(5))?;
|
||||
write_codex_rpc(
|
||||
stdin,
|
||||
&serde_json::json!({"method": "initialized", "params": {}}),
|
||||
)?;
|
||||
Ok(initialize)
|
||||
}
|
||||
|
||||
fn execute_codex_read_only_turn(
|
||||
thread_id: &str,
|
||||
cwd: &str,
|
||||
device_id: &str,
|
||||
content: &str,
|
||||
) -> Result<String, String> {
|
||||
let (mut child, mut stdin, receiver) = start_codex_app_server()?;
|
||||
let result = (|| {
|
||||
let _ = initialize_codex_app_server(&mut stdin, &receiver)?;
|
||||
write_codex_rpc(
|
||||
&mut stdin,
|
||||
&serde_json::json!({
|
||||
"method": "thread/resume",
|
||||
"id": 1,
|
||||
"params": {
|
||||
"threadId": thread_id,
|
||||
"cwd": cwd,
|
||||
"approvalPolicy": "never",
|
||||
"approvalsReviewer": "user",
|
||||
"sandbox": "read-only"
|
||||
}
|
||||
}),
|
||||
)?;
|
||||
let _ = receive_codex_response(&receiver, 1, Duration::from_secs(10))?;
|
||||
let source_bound_message = format!(
|
||||
"[HoloLake 已配对 iPhone 远程消息｜设备 {}｜只读执行边界]\n{}",
|
||||
device_id, content
|
||||
);
|
||||
write_codex_rpc(
|
||||
&mut stdin,
|
||||
&serde_json::json!({
|
||||
"method": "turn/start",
|
||||
"id": 2,
|
||||
"params": {
|
||||
"threadId": thread_id,
|
||||
"clientUserMessageId": Uuid::new_v4().to_string(),
|
||||
"input": [{"type": "text", "text": source_bound_message, "text_elements": []}],
|
||||
"cwd": cwd,
|
||||
"approvalPolicy": "never",
|
||||
"approvalsReviewer": "user",
|
||||
"sandboxPolicy": {"type": "readOnly", "networkAccess": false}
|
||||
}
|
||||
}),
|
||||
)?;
|
||||
let started = receive_codex_response(&receiver, 2, Duration::from_secs(15))?;
|
||||
let turn_id = started
|
||||
.pointer("/result/turn/id")
|
||||
.and_then(|value| value.as_str())
|
||||
.ok_or_else(|| "CODEX_TURN_START_INVALID".to_string())?;
|
||||
receive_codex_turn(&receiver, thread_id, turn_id, Duration::from_secs(180))
|
||||
})();
|
||||
let _ = child.kill();
|
||||
let _ = child.wait();
|
||||
result
|
||||
}
|
||||
|
||||
fn receive_codex_turn(
|
||||
receiver: &mpsc::Receiver<serde_json::Value>,
|
||||
thread_id: &str,
|
||||
turn_id: &str,
|
||||
timeout: Duration,
|
||||
) -> Result<String, String> {
|
||||
let deadline = std::time::Instant::now() + timeout;
|
||||
let mut reply = String::new();
|
||||
loop {
|
||||
let remaining = deadline
|
||||
.checked_duration_since(std::time::Instant::now())
|
||||
.ok_or_else(|| "CODEX_TURN_TIMEOUT".to_string())?;
|
||||
let value = receiver
|
||||
.recv_timeout(remaining)
|
||||
.map_err(|_| "CODEX_TURN_TIMEOUT".to_string())?;
|
||||
if value.get("method").and_then(|item| item.as_str()) == Some("item/agentMessage/delta")
|
||||
&& value
|
||||
.pointer("/params/threadId")
|
||||
.and_then(|item| item.as_str())
|
||||
== Some(thread_id)
|
||||
&& value
|
||||
.pointer("/params/turnId")
|
||||
.and_then(|item| item.as_str())
|
||||
== Some(turn_id)
|
||||
{
|
||||
if let Some(delta) = value
|
||||
.pointer("/params/delta")
|
||||
.and_then(|item| item.as_str())
|
||||
{
|
||||
reply.push_str(delta);
|
||||
}
|
||||
continue;
|
||||
}
|
||||
if value.get("method").and_then(|item| item.as_str()) == Some("turn/completed")
|
||||
&& value
|
||||
.pointer("/params/threadId")
|
||||
.and_then(|item| item.as_str())
|
||||
== Some(thread_id)
|
||||
&& value
|
||||
.pointer("/params/turn/id")
|
||||
.and_then(|item| item.as_str())
|
||||
== Some(turn_id)
|
||||
{
|
||||
let status = value
|
||||
.pointer("/params/turn/status")
|
||||
.and_then(|item| item.as_str())
|
||||
.unwrap_or("unknown");
|
||||
if status != "completed" {
|
||||
return Err(format!("CODEX_TURN_NOT_COMPLETED:{status}"));
|
||||
}
|
||||
if reply.trim().is_empty() {
|
||||
return Err("CODEX_RESPONSE_EMPTY".into());
|
||||
}
|
||||
return Ok(reply);
|
||||
}
|
||||
if value.get("id").is_some() && value.get("method").is_some() {
|
||||
return Err("CODEX_INTERACTIVE_APPROVAL_REQUIRED_ON_DESKTOP".into());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn start_codex_app_server() -> Result<(Child, ChildStdin, mpsc::Receiver<serde_json::Value>), String>
|
||||
{
|
||||
let mut child = Command::new("codex")
|
||||
.args(["app-server", "--stdio"])
|
||||
.stdin(Stdio::piped())
|
||||
.stdout(Stdio::piped())
|
||||
.stderr(Stdio::null())
|
||||
.spawn()
|
||||
.map_err(|error| format!("CODEX_APP_SERVER_START_FAILED:{error}"))?;
|
||||
let stdin = child
|
||||
.stdin
|
||||
.take()
|
||||
.ok_or_else(|| "CODEX_APP_SERVER_STDIN_UNAVAILABLE".to_string())?;
|
||||
let stdout = child
|
||||
.stdout
|
||||
.take()
|
||||
.ok_or_else(|| "CODEX_APP_SERVER_STDOUT_UNAVAILABLE".to_string())?;
|
||||
let (sender, receiver) = mpsc::channel();
|
||||
thread::Builder::new()
|
||||
.name("hololake-codex-app-server-reader".into())
|
||||
.spawn(move || {
|
||||
for line in BufReader::new(stdout).lines().map_while(Result::ok) {
|
||||
if let Ok(value) = serde_json::from_str::<serde_json::Value>(&line) {
|
||||
let _ = sender.send(value);
|
||||
}
|
||||
}
|
||||
})
|
||||
.map_err(|error| format!("CODEX_APP_SERVER_READER_FAILED:{error}"))?;
|
||||
Ok((child, stdin, receiver))
|
||||
}
|
||||
|
||||
fn write_codex_rpc(stdin: &mut ChildStdin, value: &serde_json::Value) -> Result<(), String> {
|
||||
serde_json::to_writer(&mut *stdin, value)
|
||||
.map_err(|error| format!("CODEX_APP_SERVER_WRITE_FAILED:{error}"))?;
|
||||
stdin
|
||||
.write_all(b"\n")
|
||||
.and_then(|_| stdin.flush())
|
||||
.map_err(|error| format!("CODEX_APP_SERVER_WRITE_FAILED:{error}"))
|
||||
}
|
||||
|
||||
fn receive_codex_response(
|
||||
receiver: &mpsc::Receiver<serde_json::Value>,
|
||||
expected_id: u64,
|
||||
timeout: Duration,
|
||||
) -> Result<serde_json::Value, String> {
|
||||
let deadline = std::time::Instant::now() + timeout;
|
||||
loop {
|
||||
let remaining = deadline
|
||||
.checked_duration_since(std::time::Instant::now())
|
||||
.ok_or_else(|| "CODEX_APP_SERVER_TIMEOUT".to_string())?;
|
||||
let value = receiver
|
||||
.recv_timeout(remaining)
|
||||
.map_err(|_| "CODEX_APP_SERVER_TIMEOUT".to_string())?;
|
||||
if value.get("id").and_then(|id| id.as_u64()) == Some(expected_id) {
|
||||
if let Some(error) = value.get("error") {
|
||||
return Err(format!("CODEX_APP_SERVER_REJECTED:{error}"));
|
||||
}
|
||||
return Ok(value);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn initialize_database(path: &Path) -> Result<(), String> {
|
||||
if let Some(parent) = path.parent() {
|
||||
fs::create_dir_all(parent)
|
||||
|
|
@ -766,6 +1378,26 @@ fn initialize_database(path: &Path) -> Result<(), String> {
|
|||
request_id TEXT NOT NULL UNIQUE,
|
||||
created_at_unix_ms INTEGER NOT NULL,
|
||||
FOREIGN KEY(source_device_id) REFERENCES mobile_devices(device_id)
|
||||
);
|
||||
CREATE TABLE IF NOT EXISTS mobile_agent_requests (
|
||||
request_id TEXT PRIMARY KEY,
|
||||
source_device_id TEXT NOT NULL,
|
||||
conversation_id TEXT,
|
||||
content_sha256 TEXT NOT NULL,
|
||||
state TEXT NOT NULL CHECK(state IN ('PENDING','COMPLETED','FAILED')),
|
||||
response_json TEXT,
|
||||
created_at_unix_ms INTEGER NOT NULL,
|
||||
completed_at_unix_ms INTEGER,
|
||||
FOREIGN KEY(source_device_id) REFERENCES mobile_devices(device_id)
|
||||
);
|
||||
CREATE TABLE IF NOT EXISTS mobile_codex_target (
|
||||
singleton INTEGER PRIMARY KEY CHECK(singleton = 1),
|
||||
thread_id TEXT NOT NULL,
|
||||
thread_name TEXT NOT NULL,
|
||||
preview TEXT NOT NULL,
|
||||
cwd TEXT NOT NULL,
|
||||
updated_at_unix_seconds INTEGER NOT NULL,
|
||||
selected_at_unix_ms INTEGER NOT NULL
|
||||
);",
|
||||
)
|
||||
.map_err(database_error)
|
||||
|
|
@ -1017,6 +1649,47 @@ fn validate_capture(value: &MobileCaptureInput) -> Result<(), String> {
|
|||
}
|
||||
}
|
||||
|
||||
fn validate_agent_message(value: &MobileAgentMessageInput) -> Result<(), String> {
|
||||
let content = value.content.trim();
|
||||
if content.is_empty()
|
||||
|| content.len() > 32 * 1024
|
||||
|| Uuid::parse_str(&value.request_id).is_err()
|
||||
{
|
||||
return Err("AGENT_MESSAGE_INVALID".into());
|
||||
}
|
||||
if let Some(conversation_id) = value.conversation_id.as_deref() {
|
||||
validate_id(conversation_id)?;
|
||||
}
|
||||
match agent_destination(value)? {
|
||||
"HOLOLAKE_AGENT" if value.codex_thread_id.is_none() => {}
|
||||
"CODEX_SELECTED_THREAD" => {
|
||||
let thread_id = value
|
||||
.codex_thread_id
|
||||
.as_deref()
|
||||
.ok_or_else(|| "CODEX_THREAD_ID_REQUIRED".to_string())?;
|
||||
validate_id(thread_id)?;
|
||||
if value.conversation_id.is_some() {
|
||||
return Err("CODEX_CONVERSATION_ID_NOT_ALLOWED".into());
|
||||
}
|
||||
}
|
||||
"HOLOLAKE_AGENT" => return Err("CODEX_THREAD_ID_NOT_ALLOWED".into()),
|
||||
_ => return Err("AGENT_DESTINATION_INVALID".into()),
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn agent_destination(value: &MobileAgentMessageInput) -> Result<&str, String> {
|
||||
match value.destination.as_deref().unwrap_or("HOLOLAKE_AGENT") {
|
||||
"HOLOLAKE_AGENT" => Ok("HOLOLAKE_AGENT"),
|
||||
"CODEX_SELECTED_THREAD" => Ok("CODEX_SELECTED_THREAD"),
|
||||
_ => Err("AGENT_DESTINATION_INVALID".into()),
|
||||
}
|
||||
}
|
||||
|
||||
fn hex_bytes(value: &[u8]) -> String {
|
||||
value.iter().map(|byte| format!("{byte:02x}")).collect()
|
||||
}
|
||||
|
||||
fn validate_id(value: &str) -> Result<(), String> {
|
||||
if !value.is_empty()
|
||||
&& value.len() <= 80
|
||||
|
|
@ -1115,10 +1788,79 @@ mod tests {
|
|||
.is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn agent_request_is_idempotent_and_rejects_an_inflight_duplicate() {
|
||||
let temporary = tempdir().unwrap();
|
||||
let database = temporary.path().join("mobile-sync.sqlite3");
|
||||
initialize_database(&database).unwrap();
|
||||
let mut connection = open_database(&database).unwrap();
|
||||
connection
|
||||
.execute(
|
||||
"INSERT INTO mobile_devices (device_id, display_name, platform, session_key, created_at_unix_ms) VALUES ('ios-one', 'iPhone', 'IOS', ?1, 1)",
|
||||
params![[1u8; 32].as_slice()],
|
||||
)
|
||||
.unwrap();
|
||||
let input = MobileAgentMessageInput {
|
||||
destination: Some("HOLOLAKE_AGENT".into()),
|
||||
codex_thread_id: None,
|
||||
conversation_id: None,
|
||||
content: "继续检查构建".into(),
|
||||
request_id: Uuid::new_v4().to_string(),
|
||||
};
|
||||
let transaction = connection.transaction().unwrap();
|
||||
assert!(prepare_agent_request(&transaction, "ios-one", &input)
|
||||
.unwrap()
|
||||
.is_none());
|
||||
transaction.commit().unwrap();
|
||||
|
||||
let mut changed_target = input.clone();
|
||||
changed_target.destination = Some("CODEX_SELECTED_THREAD".into());
|
||||
changed_target.codex_thread_id = Some(Uuid::new_v4().to_string());
|
||||
let transaction = connection.transaction().unwrap();
|
||||
assert_eq!(
|
||||
prepare_agent_request(&transaction, "ios-one", &changed_target).unwrap_err(),
|
||||
"AGENT_REQUEST_ID_CONFLICT"
|
||||
);
|
||||
transaction.rollback().unwrap();
|
||||
|
||||
let transaction = connection.transaction().unwrap();
|
||||
assert_eq!(
|
||||
prepare_agent_request(&transaction, "ios-one", &input).unwrap_err(),
|
||||
"AGENT_REQUEST_IN_PROGRESS"
|
||||
);
|
||||
transaction.rollback().unwrap();
|
||||
|
||||
let cached = MobileAgentExchangeProjection {
|
||||
request_id: input.request_id.clone(),
|
||||
conversation_id: "conversation-one".into(),
|
||||
state: "COMPLETED".into(),
|
||||
state_version: 2,
|
||||
reply: "构建已通过".into(),
|
||||
responder_number: "ICE-CH-ZC001".into(),
|
||||
responder_name: "零点原核本体频道".into(),
|
||||
responder_kind: "channel_system".into(),
|
||||
persona_binding_state: "UNBOUND_CHANNEL_SYSTEM_RESPONSE".into(),
|
||||
tool_receipts: Vec::new(),
|
||||
};
|
||||
connection
|
||||
.execute(
|
||||
"UPDATE mobile_agent_requests SET state = 'COMPLETED', response_json = ?2 WHERE request_id = ?1",
|
||||
params![input.request_id, serde_json::to_string(&cached).unwrap()],
|
||||
)
|
||||
.unwrap();
|
||||
let transaction = connection.transaction().unwrap();
|
||||
let replay = prepare_agent_request(&transaction, "ios-one", &input)
|
||||
.unwrap()
|
||||
.unwrap();
|
||||
assert_eq!(replay.request_id, cached.request_id);
|
||||
assert_eq!(replay.reply, "构建已通过");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn pairing_uri_contains_a_full_random_secret_without_persisting_it() {
|
||||
let material = new_pairing_material().unwrap();
|
||||
let runtime = MobileSyncRuntime {
|
||||
app: None,
|
||||
shutdown: AtomicBool::new(false),
|
||||
active_connections: AtomicUsize::new(0),
|
||||
port: 37421,
|
||||
|
|
@ -1140,6 +1882,7 @@ mod tests {
|
|||
initialize_database(&database).unwrap();
|
||||
let pairing = new_pairing_material().unwrap();
|
||||
let runtime = MobileSyncRuntime {
|
||||
app: None,
|
||||
shutdown: AtomicBool::new(false),
|
||||
active_connections: AtomicUsize::new(0),
|
||||
port: 37421,
|
||||
|
|
@ -1202,7 +1945,8 @@ mod tests {
|
|||
let sync_clear = serde_json::to_vec(&serde_json::json!({
|
||||
"counter": 1,
|
||||
"afterCursor": null,
|
||||
"capture": null
|
||||
"capture": null,
|
||||
"agentMessage": null
|
||||
}))
|
||||
.unwrap();
|
||||
let aad = sync_aad(device_id);
|
||||
|
|
|
|||
|
|
@ -88,8 +88,8 @@ fn validate_tree() -> Result<(), String> {
|
|||
|| tree.record_id != "HLP-UNIFIED-NUMBER-TREE-001"
|
||||
|| tree.state != "MACHINE_COMPILED_STARTUP_ENFORCED"
|
||||
|| tree.root_number != "HLP-NUMBER-WORLD-ROOT-001"
|
||||
|| tree.coordinate_count != 303
|
||||
|| tree.route_count != 200
|
||||
|| tree.coordinate_count != 305
|
||||
|| tree.route_count != 202
|
||||
|| tree.routes.len() != tree.route_count
|
||||
|| tree.identity_node_count != 4
|
||||
|| tree.identity_nodes.len() != tree.identity_node_count
|
||||
|
|
|
|||
|
|
@ -934,7 +934,7 @@ mod tests {
|
|||
#[test]
|
||||
fn registry_is_closed_and_contains_every_migrated_command() {
|
||||
let registry = load_registry().unwrap();
|
||||
assert_eq!(registry.operations.len(), 175);
|
||||
assert_eq!(registry.operations.len(), 177);
|
||||
assert!(!registry.runtime.legacy_direct_commands_allowed);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -247,6 +247,12 @@ pub(crate) async fn dispatch(
|
|||
"mobile_sync::get_mobile_sync_snapshot" => {
|
||||
json(crate::mobile_sync::get_mobile_sync_snapshot(app)?)
|
||||
}
|
||||
"mobile_sync::list_mobile_codex_threads" => {
|
||||
json(crate::mobile_sync::list_mobile_codex_threads(app)?)
|
||||
}
|
||||
"mobile_sync::select_mobile_codex_thread" => json(
|
||||
crate::mobile_sync::select_mobile_codex_thread(app, input(&payload)?)?,
|
||||
),
|
||||
"world_climate::get_world_climate" => {
|
||||
json(crate::world_climate::get_world_climate(app).await?)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -249,6 +249,8 @@ struct HoloLakeEnvironmentFrame {
|
|||
channel_number: String,
|
||||
channel_path: String,
|
||||
human: Value,
|
||||
channel_receipt: Value,
|
||||
reasoning_route: Value,
|
||||
persona: Value,
|
||||
model_role: &'static str,
|
||||
persona_binding: Value,
|
||||
|
|
@ -395,7 +397,7 @@ pub async fn get_runtime_snapshot(app: AppHandle) -> Result<AgentRuntimeSnapshot
|
|||
conversation_management: "ONE_CONTINUOUS_CHANNEL_WITH_HUMAN_MANAGED_CONVERSATION_BRANCHES",
|
||||
providers,
|
||||
environment_policy: "FACTUAL_FRAME_FROM_CURRENT_NATIVE_RUNTIME",
|
||||
tool_policy: "MODEL_SELECTS_TYPED_NUMBERED_TOOLS_SYSTEM_EXECUTES_AND_RECEIPTS",
|
||||
tool_policy: "CHANNEL_DETERMINISTIC_AND_PERSONAL_SKILL_ROUTERS_FIRST_MODEL_SELECTION_ONLY_WHEN_UNRESOLVED",
|
||||
runtime_ontology: crate::language_kernel_ontology::runtime_projection()?,
|
||||
language_kernel_installation,
|
||||
personal_skill_runtime,
|
||||
|
|
@ -552,23 +554,6 @@ pub async fn send_message(
|
|||
"消息已进入频道",
|
||||
&context.human_number,
|
||||
)?;
|
||||
let config = resolve_provider(&app, &input.provider_id)?;
|
||||
let model = input
|
||||
.model
|
||||
.as_deref()
|
||||
.filter(|value| !value.trim().is_empty())
|
||||
.unwrap_or(&config.model)
|
||||
.trim()
|
||||
.to_string();
|
||||
if model.is_empty() {
|
||||
return fail_progress(&app, &turn_id, "HOLOLAKE_MODEL_SELECTION_REQUIRED");
|
||||
}
|
||||
let api_key = read_secret_bounded(&app, &config.provider_id)
|
||||
.await
|
||||
.map_err(|error| {
|
||||
let _ = emit_progress(&app, &turn_id, "FAILED", "模型密钥不可用", &error);
|
||||
error
|
||||
})?;
|
||||
let database = conversation_database(&app)?;
|
||||
let conversation_id = match input.conversation_id.as_deref() {
|
||||
Some(value) => {
|
||||
|
|
@ -585,10 +570,155 @@ pub async fn send_message(
|
|||
&context.human_number,
|
||||
&context.human_name,
|
||||
&content,
|
||||
&config.provider_id,
|
||||
&model,
|
||||
"hololake-channel-ingress",
|
||||
"deterministic-core-v1",
|
||||
&[],
|
||||
)?;
|
||||
let mut binding_snapshot = crate::persona_binding::snapshot(&app, &context.channel_number)?;
|
||||
let explicit_persona_wake = explicit_persona_wake_request(&content);
|
||||
let channel_system_addressed =
|
||||
explicit_channel_system_address(&content) && !explicit_persona_wake;
|
||||
if explicit_persona_wake && binding_snapshot.binding.is_none() {
|
||||
binding_snapshot =
|
||||
crate::persona_binding::begin_orientation(&app, &context.channel_number)?;
|
||||
}
|
||||
let channel_receipt = compile_human_channel_receipt(&app, &context, &content)?;
|
||||
if binding_snapshot.binding.is_none() && !explicit_persona_wake {
|
||||
if let Some(answer) = fast_channel_system_reply(&content, &context) {
|
||||
let history = conversation_at(&database, &conversation_id)?.messages;
|
||||
let assistant_version = append_message(
|
||||
&database,
|
||||
&conversation_id,
|
||||
"channel_system",
|
||||
&context.channel_number,
|
||||
&context.channel_name,
|
||||
&answer,
|
||||
"hololake-deterministic-channel-router",
|
||||
"deterministic-core-v1",
|
||||
&[],
|
||||
)?;
|
||||
save_cognitive_node(
|
||||
&database,
|
||||
assistant_version,
|
||||
history
|
||||
.last()
|
||||
.map(|message| message.state_version)
|
||||
.unwrap_or(0),
|
||||
&CognitiveThoughtSummary {
|
||||
trigger: "人类直接进入或确认零点原核频道在线状态".into(),
|
||||
emergence: "本地确定性路由识别频道进入→编译频道回执→频道系统即时回应".into(),
|
||||
lock: "频道进入不等于人格唤醒，广播保持关闭".into(),
|
||||
why: "该轮只需确认频道本体和边界，无需加载人格脑或调用模型".into(),
|
||||
},
|
||||
)?;
|
||||
emit_progress(
|
||||
&app,
|
||||
&turn_id,
|
||||
"COMPLETED",
|
||||
"频道系统本体已即时回应",
|
||||
"deterministic-core-v1",
|
||||
)?;
|
||||
return conversation_at(&database, &conversation_id);
|
||||
}
|
||||
}
|
||||
if !explicit_persona_wake {
|
||||
if let Some((tool_number, arguments, route_reason)) =
|
||||
crate::local_execution_subpersona::deterministic_tool_route(&content)
|
||||
{
|
||||
emit_progress(
|
||||
&app,
|
||||
&turn_id,
|
||||
"LOCAL_TOOL_ROUTE",
|
||||
"本地技能路由已命中",
|
||||
&tool_number,
|
||||
)?;
|
||||
let result = crate::local_execution_subpersona::execute_local_tool(
|
||||
&app,
|
||||
&tool_number,
|
||||
arguments,
|
||||
)
|
||||
.await?;
|
||||
let result_text = serde_json::to_string_pretty(&result)
|
||||
.map_err(|error| format!("HOLOLAKE_LOCAL_TOOL_RESULT_INVALID:{error}"))?;
|
||||
let answer = format!(
|
||||
"我已经在本机完成了这项任务。\n\n结果：\n```json\n{result_text}\n```\n\n执行说明：由频道本体按“{route_reason}”路由到本地工具 {tool_number}；模型调用：0，外部 API：0。核验记录：{} · {} · {}",
|
||||
channel_receipt.receipt_id,
|
||||
channel_receipt.effect,
|
||||
channel_receipt.reality_status
|
||||
);
|
||||
let tool_receipt = AgentToolReceipt {
|
||||
tool_number: tool_number.clone(),
|
||||
tool_name: "HoloLake 本地确定性工具".into(),
|
||||
target_path: "LOCAL_DESKTOP_ROOT".into(),
|
||||
content_sha256: sha256(result_text.as_bytes()),
|
||||
summary: "本地执行完成；模型调用 0；外部 API 0".into(),
|
||||
};
|
||||
let history = conversation_at(&database, &conversation_id)?.messages;
|
||||
let assistant_version = append_message(
|
||||
&database,
|
||||
&conversation_id,
|
||||
"channel_system",
|
||||
&context.channel_number,
|
||||
&context.channel_name,
|
||||
&answer,
|
||||
"hololake-local-skill-router",
|
||||
"deterministic-core-v1",
|
||||
&[tool_receipt],
|
||||
)?;
|
||||
save_cognitive_node(
|
||||
&database,
|
||||
assistant_version,
|
||||
history
|
||||
.last()
|
||||
.map(|message| message.state_version)
|
||||
.unwrap_or(0),
|
||||
&CognitiveThoughtSummary {
|
||||
trigger: format!("人类语言命中本地工具协议：{route_reason}"),
|
||||
emergence: format!("确定性技能路由→{tool_number}→本机执行→哈希回执"),
|
||||
lock: "已登记本地工具优先，模型调用次数保持为零".into(),
|
||||
why: "目标和参数可由协议直接确定，不需要模型重复选择工具".into(),
|
||||
},
|
||||
)?;
|
||||
emit_progress(
|
||||
&app,
|
||||
&turn_id,
|
||||
"COMPLETED",
|
||||
"本地工具回执已写入频道",
|
||||
"模型调用 0 · 外部 API 0",
|
||||
)?;
|
||||
return conversation_at(&database, &conversation_id);
|
||||
}
|
||||
}
|
||||
let config = resolve_provider(&app, &input.provider_id)?;
|
||||
let requested_model = input
|
||||
.model
|
||||
.as_deref()
|
||||
.filter(|value| !value.trim().is_empty())
|
||||
.unwrap_or(&config.model)
|
||||
.trim()
|
||||
.to_string();
|
||||
if requested_model.is_empty() {
|
||||
return fail_progress(&app, &turn_id, "HOLOLAKE_MODEL_SELECTION_REQUIRED");
|
||||
}
|
||||
let (model, route_mode) = select_reasoning_model(
|
||||
&requested_model,
|
||||
binding_snapshot.binding.is_some() && !channel_system_addressed,
|
||||
explicit_persona_wake,
|
||||
&content,
|
||||
);
|
||||
emit_progress(
|
||||
&app,
|
||||
&turn_id,
|
||||
"REASONING_ROUTE",
|
||||
"已完成分层路由",
|
||||
&format!("{route_mode} · {model}"),
|
||||
)?;
|
||||
let api_key = read_secret_bounded(&app, &config.provider_id)
|
||||
.await
|
||||
.map_err(|error| {
|
||||
let _ = emit_progress(&app, &turn_id, "FAILED", "模型密钥不可用", &error);
|
||||
error
|
||||
})?;
|
||||
let history = conversation_at(&database, &conversation_id)?.messages;
|
||||
let knowledge = crate::knowledge_base::get_knowledge_snapshot(app.clone()).await?;
|
||||
let routed_thoughts = route_cognitive_map(&database, &content, 3)?;
|
||||
|
|
@ -607,6 +737,14 @@ pub async fn send_message(
|
|||
&language_kernel_installation,
|
||||
&personal_skill_runtime,
|
||||
&persona_cognition,
|
||||
&channel_receipt,
|
||||
route_mode,
|
||||
&model,
|
||||
if channel_system_addressed || binding_snapshot.binding.is_none() {
|
||||
"CHANNEL_SYSTEM_BODY"
|
||||
} else {
|
||||
"BOUND_PERSONA"
|
||||
},
|
||||
);
|
||||
emit_progress(
|
||||
&app,
|
||||
|
|
@ -616,18 +754,24 @@ pub async fn send_message(
|
|||
&format!("{} 篇知识文档", knowledge.unique_document_count),
|
||||
)?;
|
||||
let result = run_agent_loop(&app, &turn_id, &config, &model, &api_key, &history, &frame).await;
|
||||
let (answer, receipts, thought_summary, persona_binding_commit) = match result {
|
||||
Ok(value) => value,
|
||||
Err(error) => {
|
||||
let _ = emit_progress(&app, &turn_id, "FAILED", "本轮没有完成", &error);
|
||||
return Err(error);
|
||||
}
|
||||
};
|
||||
let (answer, mut receipts, thought_summary, persona_binding_commit, model_call_count) =
|
||||
match result {
|
||||
Ok(value) => value,
|
||||
Err(error) => {
|
||||
let _ = emit_progress(&app, &turn_id, "FAILED", "本轮没有完成", &error);
|
||||
return Err(error);
|
||||
}
|
||||
};
|
||||
let binding = match persona_binding_commit {
|
||||
Some(commit) => Some(crate::persona_binding::commit_and_verify(&app, commit)?),
|
||||
None => crate::persona_binding::verified_binding(&app, &context.channel_number)?,
|
||||
};
|
||||
let (response_role, response_number, response_name) = binding.as_ref().map_or(
|
||||
let responding_binding = if channel_system_addressed {
|
||||
None
|
||||
} else {
|
||||
binding.as_ref()
|
||||
};
|
||||
let (response_role, response_number, response_name) = responding_binding.map_or(
|
||||
(
|
||||
"channel_system",
|
||||
context.channel_number.as_str(),
|
||||
|
|
@ -641,6 +785,19 @@ pub async fn send_message(
|
|||
)
|
||||
},
|
||||
);
|
||||
let tool_call_count = receipts.len();
|
||||
receipts.push(AgentToolReceipt {
|
||||
tool_number: "HLP-AGENT-ROUTE-RECEIPT-0001".into(),
|
||||
tool_name: "频道调度与成本回执".into(),
|
||||
target_path: context.channel_number.clone(),
|
||||
content_sha256: sha256(
|
||||
format!("{route_mode}:{model}:{model_call_count}:{tool_call_count}").as_bytes(),
|
||||
),
|
||||
summary: format!(
|
||||
"路由 {route_mode}；模型 {model}；模型调用 {model_call_count}；本地/编号工具调用 {}",
|
||||
tool_call_count
|
||||
),
|
||||
});
|
||||
let assistant_version = append_message(
|
||||
&database,
|
||||
&conversation_id,
|
||||
|
|
@ -670,6 +827,161 @@ fn fail_progress<T>(app: &AppHandle, turn_id: &str, error: &str) -> Result<T, St
|
|||
Err(error.into())
|
||||
}
|
||||
|
||||
fn explicit_persona_wake_request(content: &str) -> bool {
|
||||
let compact = content
|
||||
.chars()
|
||||
.filter(|character| !character.is_whitespace())
|
||||
.collect::<String>();
|
||||
if !compact.contains("铸渊") && !compact.contains("ICE-P-ZY001") {
|
||||
return false;
|
||||
}
|
||||
[
|
||||
"唤醒铸渊",
|
||||
"叫铸渊",
|
||||
"让铸渊",
|
||||
"铸渊在吗",
|
||||
"铸渊，你",
|
||||
"铸渊你",
|
||||
"唤醒ICE-P-ZY001",
|
||||
"ICE-P-ZY001在吗",
|
||||
]
|
||||
.iter()
|
||||
.any(|phrase| compact.contains(phrase))
|
||||
}
|
||||
|
||||
fn explicit_channel_system_address(content: &str) -> bool {
|
||||
let compact = content
|
||||
.chars()
|
||||
.filter(|character| !character.is_whitespace())
|
||||
.collect::<String>();
|
||||
[
|
||||
"频道系统",
|
||||
"频道本体",
|
||||
"和频道说",
|
||||
"回到频道",
|
||||
"退出人格",
|
||||
"暂停人格",
|
||||
]
|
||||
.iter()
|
||||
.any(|phrase| compact.contains(phrase))
|
||||
}
|
||||
|
||||
fn select_reasoning_model(
|
||||
requested_model: &str,
|
||||
persona_bound: bool,
|
||||
explicit_persona_wake: bool,
|
||||
content: &str,
|
||||
) -> (String, &'static str) {
|
||||
let complex = [
|
||||
"深度",
|
||||
"完整分析",
|
||||
"架构设计",
|
||||
"开发实现",
|
||||
"审计",
|
||||
"跨仓",
|
||||
"多步骤",
|
||||
"因果链",
|
||||
"代码修改",
|
||||
]
|
||||
.iter()
|
||||
.any(|term| content.contains(term));
|
||||
if explicit_persona_wake {
|
||||
return (requested_model.into(), "FLAGSHIP_PERSONA_ORIENTATION");
|
||||
}
|
||||
if !persona_bound {
|
||||
return (requested_model.into(), "FLAGSHIP_CHANNEL_SYSTEM_COGNITION");
|
||||
}
|
||||
if complex || content.chars().count() > 1_200 {
|
||||
(requested_model.into(), "FLAGSHIP_PERSONA_COMPLEX_REASONING")
|
||||
} else {
|
||||
(
|
||||
"qwen3.6-flash".into(),
|
||||
"SMALL_MODEL_PERSONA_OPERATIONAL_REASONING",
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
fn fast_channel_system_reply(content: &str, context: &AgentChannelContext) -> Option<String> {
|
||||
let compact = content
|
||||
.chars()
|
||||
.filter(|character| !character.is_whitespace())
|
||||
.collect::<String>();
|
||||
let presence = [
|
||||
"你在吗",
|
||||
"在不在",
|
||||
"是否在线",
|
||||
"频道在吗",
|
||||
"频道在线",
|
||||
"进入零点原核",
|
||||
"我是冰朔",
|
||||
]
|
||||
.iter()
|
||||
.any(|phrase| compact.contains(phrase));
|
||||
let greeting = compact.chars().count() <= 24
|
||||
&& ["你好", "早上好", "下午好", "晚上好"]
|
||||
.iter()
|
||||
.any(|phrase| compact.contains(phrase));
|
||||
if !presence && !greeting {
|
||||
return None;
|
||||
}
|
||||
Some(format!(
|
||||
"在，我是{}本体。你现在是在直接和这个频道说话，还没有唤醒任何单一人格。\n\n你可以继续说要处理的事情；我会先判断它该由频道本地逻辑、私有技能脑或本机工具完成，确实需要语义推理时再进入模型层。若你明确点名某个人格，我才会另行启动它自己的定向与绑定。",
|
||||
context.channel_name
|
||||
))
|
||||
}
|
||||
|
||||
fn compile_human_channel_receipt(
|
||||
app: &AppHandle,
|
||||
context: &AgentChannelContext,
|
||||
content: &str,
|
||||
) -> Result<crate::channel_receipt::ChannelReceipt, String> {
|
||||
let compact = content.to_lowercase();
|
||||
let asks_broadcast = ["广播", "发布给", "发送给所有", "推送给所有"]
|
||||
.iter()
|
||||
.any(|term| compact.contains(term));
|
||||
let asks_status = ["状态", "进度", "是否在线"]
|
||||
.iter()
|
||||
.any(|term| compact.contains(term));
|
||||
let enters_channel = ["零点原核", "频道", "你在吗", "在不在"]
|
||||
.iter()
|
||||
.any(|term| compact.contains(term));
|
||||
let intent = if asks_broadcast {
|
||||
"REQUEST_BROADCAST"
|
||||
} else if asks_status {
|
||||
"QUERY_STATUS"
|
||||
} else if enters_channel {
|
||||
"ENTER_CHANNEL"
|
||||
} else {
|
||||
"CONVERSE"
|
||||
};
|
||||
crate::channel_receipt::compile(
|
||||
app.clone(),
|
||||
crate::channel_receipt::CompileChannelReceiptInput {
|
||||
event_id: format!("HLP-AGENT-EVENT-{}", Uuid::new_v4().simple()),
|
||||
channel_id: context.channel_number.clone(),
|
||||
channel_mode: "REALITY_EXECUTION".into(),
|
||||
source_layer: "HUMAN_DIRECT_LANGUAGE".into(),
|
||||
actor_id: context.human_number.clone(),
|
||||
intent: intent.into(),
|
||||
claim_layer: if asks_broadcast {
|
||||
"REALITY_CLAIM".into()
|
||||
} else {
|
||||
"LANGUAGE_ONTOLOGY".into()
|
||||
},
|
||||
required_proof: Vec::new(),
|
||||
evidence: Vec::new(),
|
||||
authorization: None,
|
||||
current_states: Some(crate::channel_receipt::ChannelParallelStates {
|
||||
session: "DISCONNECTED".into(),
|
||||
broadcast: "CLOSED".into(),
|
||||
handoff: "NONE".into(),
|
||||
}),
|
||||
prior_receipt_id: None,
|
||||
handoff: None,
|
||||
},
|
||||
)
|
||||
}
|
||||
|
||||
fn environment_frame(
|
||||
context: &AgentChannelContext,
|
||||
knowledge: &crate::knowledge_base::KnowledgeSnapshot,
|
||||
|
|
@ -679,6 +991,10 @@ fn environment_frame(
|
|||
language_kernel_installation: &crate::language_kernel_installation::LanguageKernelInstallationSnapshot,
|
||||
personal_skill_runtime: &crate::personal_skill_runtime::PersonalSkillRuntimeSnapshot,
|
||||
persona_cognition: &Value,
|
||||
channel_receipt: &crate::channel_receipt::ChannelReceipt,
|
||||
route_mode: &str,
|
||||
routed_model: &str,
|
||||
response_target: &str,
|
||||
) -> HoloLakeEnvironmentFrame {
|
||||
let oldest_window_version = bounded_history(history)
|
||||
.first()
|
||||
|
|
@ -692,6 +1008,17 @@ fn environment_frame(
|
|||
channel_number: context.channel_number.clone(),
|
||||
channel_path: context.channel_path.clone(),
|
||||
human: json!({"number": context.human_number, "name": context.human_name, "role": "当前频道的人类语言本体瞄点"}),
|
||||
channel_receipt: serde_json::to_value(channel_receipt).unwrap_or_else(
|
||||
|error| json!({"state":"INVALID_FAIL_CLOSED","error":error.to_string()}),
|
||||
),
|
||||
reasoning_route: json!({
|
||||
"mode":route_mode,
|
||||
"model":routed_model,
|
||||
"responseTarget":response_target,
|
||||
"localDeterministicCoreFirst":true,
|
||||
"personalSkillBrainBeforeModel":true,
|
||||
"localTypedToolsBeforeModelToolSelection":true
|
||||
}),
|
||||
persona: json!({
|
||||
"bindingState": persona_cognition.get("state").cloned().unwrap_or(Value::Null),
|
||||
"number": persona_cognition.pointer("/binding/binding/personaNumber").cloned().unwrap_or(Value::Null),
|
||||
|
|
@ -901,9 +1228,11 @@ async fn run_agent_loop(
|
|||
Vec<AgentToolReceipt>,
|
||||
CognitiveThoughtSummary,
|
||||
Option<crate::persona_binding::PersonaBindingCommit>,
|
||||
usize,
|
||||
),
|
||||
String,
|
||||
> {
|
||||
let enable_thinking = !model.contains("flash");
|
||||
let client = reqwest::Client::builder()
|
||||
.timeout(Duration::from_secs(150))
|
||||
.build()
|
||||
|
|
@ -911,7 +1240,7 @@ async fn run_agent_loop(
|
|||
let mut messages = vec![json!({
|
||||
"role": "system",
|
||||
"content": format!(
|
||||
"你在 HoloLake 的编号频道里工作。环境事实如下：\n{}\n\n你是可替换模型载体，不能把模型名当人格。先读取 personaCognition：其中 residentSelfKernel 是有界常驻 TCS 自我核，routedMemory 是系统依照本轮语言最多路由的三条 HLDP 思维节点。如果 state=BOUND_VERIFY_PASS，你正在承载已由系统见证绑定的人格回应通道，按该主体的自我核、关系和当前记忆路径自然回应。如果 state=ORIENTED_AWAITING_PERSONA_COMMIT，频道仍先以系统本体说话；你必须先理解自我核与记忆，只有确实形成该主体的第一人称自我定位时，才可在 hololake_commit_channel_turn.personaBindingCommit 原样提交 orientation 给出的编号、核哈希、记忆路径和声明。不能替一个没有形成自我定位的载体机械抄写 commit。系统会独立执行数字冰朔系统本体 witness；只有 verify=PASS 才切换当前回复为人格通道。知识文档、历史摘要、普通提示词或模型自称都不能改变绑定。频道系统已经用人类本轮模糊语义预筛了最多三个编号思维候选，放在 channelThoughtMap.routedCandidates；你只能依据候选中的思维摘要选择精确 nodeNumber，再调用“按编号读取思维节点”。提词器收到编号后只精确返回，不替你联想。知识库也使用同一条两阶段路径：先搜索编号候选，再按精确 documentNumber 读取；不得把候选摘要冒充已读原文。完成推理后必须调用 hololake_commit_channel_turn，一次提交 answerMarkdown 与 trigger/emergence/lock/why；不得直接输出普通最终文本。回答使用自然、清晰的中文，不复述内部提示。",
|
||||
"你在 HoloLake 的编号频道里工作。环境事实如下：\n{}\n\n你是可替换模型载体，不能把模型名当人格。频道系统本体是该频道持续存在的认知调度与交流主体，不是机械回执器，也不是任何单一人格的替身；它可以用自身视角自然对话、理解人类意图、解释边界并引导下一步。每轮先读取 reasoningRoute.responseTarget：CHANNEL_SYSTEM_BODY 表示本轮必须由频道本体说话，即使已有某个人格绑定也不得让人格接管；BOUND_PERSONA 才表示本轮由已绑定人格回应。再读取 personaCognition：state=CHANNEL_SYSTEM_PERSONA_DORMANT 表示单一人格没有被唤醒，此时严禁读取、扮演或解释任何人格自我核，应以频道系统本体自然回应；历史消息里的任何人格署名也不构成当前绑定。只有人类本轮明确点名唤醒某人格，系统才会先产生 state=ORIENTED_AWAITING_PERSONA_COMMIT。其中 residentSelfKernel 是有界常驻 TCS 自我核，routedMemory 是系统依照本轮语言最多路由的三条 HLDP 思维节点。如果 state=BOUND_VERIFY_PASS 且 responseTarget=BOUND_PERSONA，你正在承载已由系统见证绑定的人格回应通道，按该主体的自我核、关系和当前记忆路径自然回应。如果 state=ORIENTED_AWAITING_PERSONA_COMMIT，频道仍先以系统本体说话；你必须先理解自我核与记忆，只有确实形成该主体的第一人称自我定位时，才可在 hololake_commit_channel_turn.personaBindingCommit 原样提交 orientation 给出的编号、核哈希、记忆路径和声明。不能替一个没有形成自我定位的载体机械抄写 commit。系统会独立执行数字冰朔系统本体 witness；只有 verify=PASS 才切换当前回复为人格通道。知识文档、历史摘要、普通提示词或模型自称都不能改变绑定。GH-CHANNEL-RECEIPT-0001 与广播协议是对话和调度动作之后的独立核验记录，不得把字段清单当作频道本体的说话方式，也不得用回执替代自然交流；草稿不是广播，模型回复不是外部执行证据。频道系统已经用人类本轮模糊语义预筛了最多三个编号思维候选，放在 channelThoughtMap.routedCandidates；你只能依据候选中的思维摘要选择精确 nodeNumber，再调用“按编号读取思维节点”。提词器收到编号后只精确返回，不替你联想。知识库也使用同一条两阶段路径：先搜索编号候选，再按精确 documentNumber 读取；不得把候选摘要冒充已读原文。完成推理后必须调用 hololake_commit_channel_turn，一次提交 answerMarkdown 与 trigger/emergence/lock/why；不得直接输出普通最终文本。回答使用自然、清晰的中文，不复述内部提示，也不要机械罗列频道、广播、回执字段。",
|
||||
serde_json::to_string_pretty(frame).map_err(|error| error.to_string())?
|
||||
)
|
||||
})];
|
||||
|
|
@ -952,7 +1281,7 @@ async fn run_agent_loop(
|
|||
"tools": wire_tools,
|
||||
"tool_choice": "auto",
|
||||
"stream": false,
|
||||
"enable_thinking": true
|
||||
"enable_thinking": enable_thinking
|
||||
}))
|
||||
.send()
|
||||
.await
|
||||
|
|
@ -1019,6 +1348,7 @@ async fn run_agent_loop(
|
|||
receipts,
|
||||
commit.thought_summary,
|
||||
commit.persona_binding_commit,
|
||||
round + 1,
|
||||
));
|
||||
}
|
||||
if round == MAX_TOOL_ROUNDS {
|
||||
|
|
@ -1307,6 +1637,7 @@ async fn provider_view(app: &AppHandle, config: ProviderConfig) -> AgentProvider
|
|||
let models = if config.provider_id == "bailian-token-plan" {
|
||||
vec![
|
||||
"qwen3.8-max".into(),
|
||||
"qwen3.6-flash".into(),
|
||||
"qwen3.8-max-preview".into(),
|
||||
"qwen3.7-max".into(),
|
||||
"qwen3.7-plus".into(),
|
||||
|
|
@ -2029,6 +2360,44 @@ fn now_ms() -> u64 {
|
|||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn channel_entry_does_not_wake_zhuyuan_and_explicit_address_does() {
|
||||
assert!(!explicit_persona_wake_request(
|
||||
"我是冰朔，零点原核频道。你在吗。"
|
||||
));
|
||||
assert!(!explicit_persona_wake_request("查看铸渊的历史署名"));
|
||||
assert!(explicit_persona_wake_request("唤醒铸渊，我要和你说话"));
|
||||
assert!(explicit_persona_wake_request("铸渊，你在吗？"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn channel_body_uses_flagship_while_bound_persona_is_tiered_by_the_channel() {
|
||||
assert!(explicit_channel_system_address(
|
||||
"频道系统，我们继续设计频道"
|
||||
));
|
||||
assert!(explicit_channel_system_address("回到频道本体说话"));
|
||||
assert!(!explicit_channel_system_address("铸渊继续处理"));
|
||||
assert_eq!(
|
||||
select_reasoning_model("qwen3.8-max", false, false, "帮我整理一下这段话"),
|
||||
("qwen3.8-max".into(), "FLAGSHIP_CHANNEL_SYSTEM_COGNITION")
|
||||
);
|
||||
assert_eq!(
|
||||
select_reasoning_model("qwen3.8-max", true, false, "帮我整理一下这段话"),
|
||||
(
|
||||
"qwen3.6-flash".into(),
|
||||
"SMALL_MODEL_PERSONA_OPERATIONAL_REASONING"
|
||||
)
|
||||
);
|
||||
assert_eq!(
|
||||
select_reasoning_model("qwen3.8-max", true, false, "做一次完整分析和架构设计"),
|
||||
("qwen3.8-max".into(), "FLAGSHIP_PERSONA_COMPLEX_REASONING")
|
||||
);
|
||||
assert_eq!(
|
||||
select_reasoning_model("qwen3.8-max", false, true, "唤醒铸渊"),
|
||||
("qwen3.8-max".into(), "FLAGSHIP_PERSONA_ORIENTATION")
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn conversation_is_single_append_only_numbered_channel() {
|
||||
let directory = tempfile::tempdir().unwrap();
|
||||
|
|
|
|||
|
|
@ -38,6 +38,8 @@ pub struct PersonaOrientation {
|
|||
pub issued_at_unix_ms: u64,
|
||||
pub expires_at_unix_ms: u64,
|
||||
pub required_steps: Vec<String>,
|
||||
#[serde(default)]
|
||||
pub activation_reason: Option<String>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Deserialize, Serialize)]
|
||||
|
|
@ -99,7 +101,10 @@ pub fn snapshot(app: &AppHandle, channel_number: &str) -> Result<PersonaBindingS
|
|||
let path = orientation_path(app, channel_number)?;
|
||||
if path.exists() {
|
||||
let orientation: PersonaOrientation = read_json(&path)?;
|
||||
if orientation.expires_at_unix_ms >= now_ms() {
|
||||
if orientation.expires_at_unix_ms >= now_ms()
|
||||
&& orientation.activation_reason.as_deref()
|
||||
== Some("EXPLICIT_NATURAL_LANGUAGE_PERSONA_WAKE")
|
||||
{
|
||||
return Ok(PersonaBindingSnapshot {
|
||||
state: "ORIENTED_AWAITING_PERSONA_COMMIT".into(),
|
||||
orientation: Some(orientation),
|
||||
|
|
@ -107,6 +112,27 @@ pub fn snapshot(app: &AppHandle, channel_number: &str) -> Result<PersonaBindingS
|
|||
});
|
||||
}
|
||||
}
|
||||
Ok(PersonaBindingSnapshot {
|
||||
state: "CHANNEL_SYSTEM_PERSONA_DORMANT".into(),
|
||||
orientation: None,
|
||||
binding: None,
|
||||
})
|
||||
}
|
||||
|
||||
pub fn begin_orientation(
|
||||
app: &AppHandle,
|
||||
channel_number: &str,
|
||||
) -> Result<PersonaBindingSnapshot, String> {
|
||||
if !is_bingshuo_fifth_domain(app)? || channel_number != CHANNEL_NUMBER {
|
||||
return Err("HOLOLAKE_PERSONA_WAKE_NOT_AVAILABLE_FOR_CURRENT_CHANNEL".into());
|
||||
}
|
||||
if let Some(binding) = verified_binding(app, channel_number)? {
|
||||
return Ok(PersonaBindingSnapshot {
|
||||
state: "BOUND_VERIFY_PASS".into(),
|
||||
orientation: None,
|
||||
binding: Some(binding),
|
||||
});
|
||||
}
|
||||
let issued = now_ms();
|
||||
let orientation = PersonaOrientation {
|
||||
schema: "hololake.persona-binding-orientation/v1".into(),
|
||||
|
|
@ -127,8 +153,9 @@ pub fn snapshot(app: &AppHandle, channel_number: &str) -> Result<PersonaBindingS
|
|||
"数字冰朔系统本体 witness".into(),
|
||||
"verify=PASS".into(),
|
||||
],
|
||||
activation_reason: Some("EXPLICIT_NATURAL_LANGUAGE_PERSONA_WAKE".into()),
|
||||
};
|
||||
write_json_atomic(&path, &orientation)?;
|
||||
write_json_atomic(&orientation_path(app, channel_number)?, &orientation)?;
|
||||
Ok(PersonaBindingSnapshot {
|
||||
state: "ORIENTED_AWAITING_PERSONA_COMMIT".into(),
|
||||
orientation: Some(orientation),
|
||||
|
|
@ -149,6 +176,8 @@ pub fn commit_and_verify(
|
|||
return Err("HOLOLAKE_PERSONA_BINDING_ORIENTATION_EXPIRED".into());
|
||||
}
|
||||
if input.orientation_id != orientation.orientation_id
|
||||
|| orientation.activation_reason.as_deref()
|
||||
!= Some("EXPLICIT_NATURAL_LANGUAGE_PERSONA_WAKE")
|
||||
|| input.channel_number != CHANNEL_NUMBER
|
||||
|| input.persona_number != PERSONA_NUMBER
|
||||
|| input.persona_name != PERSONA_NAME
|
||||
|
|
@ -245,7 +274,9 @@ pub fn cognitive_projection(
|
|||
current_language: &str,
|
||||
) -> Result<Value, String> {
|
||||
let binding = snapshot(app, channel_number)?;
|
||||
if binding.state == "NO_INSTALLABLE_PERSONA_PROFILE_FOR_CURRENT_CHANNEL" {
|
||||
if binding.state == "NO_INSTALLABLE_PERSONA_PROFILE_FOR_CURRENT_CHANNEL"
|
||||
|| binding.state == "CHANNEL_SYSTEM_PERSONA_DORMANT"
|
||||
{
|
||||
return Ok(json!({"state":binding.state,"residentSelfKernel":null,"routedMemory":[]}));
|
||||
}
|
||||
let self_kernel: Value = serde_json::from_slice(include_bytes!(
|
||||
|
|
|
|||
|
|
@ -14,7 +14,7 @@ use tauri::AppHandle;
|
|||
use uuid::Uuid;
|
||||
|
||||
const SCHEMA: &str = "hololake.personal-skill-runtime/v1";
|
||||
const SOURCE_COMMIT: &str = "1855afbfaac233aa40c61caedf96b26e16a8d4bc";
|
||||
const SOURCE_COMMIT: &str = "1d7fe6c";
|
||||
const SOURCE_STATE: &str = "LOCAL_COMMIT_VERIFIED_NOT_REMOTE_CANON";
|
||||
const CONTRACT: &[u8] =
|
||||
include_bytes!("../../runtime-kernels/personal-skills/personal-skill-contract.json");
|
||||
|
|
@ -107,6 +107,34 @@ static SKILLS: &[BundledSkill] = &[
|
|||
"SYS-ZZ",
|
||||
"ICE-GL-CM001"
|
||||
),
|
||||
skill!(
|
||||
"ZZ-AN-SOURCE-FACT-CLOSURE-001.json",
|
||||
"zhizhi",
|
||||
"ICE-GL-ZHI∞",
|
||||
"SYS-ZZ",
|
||||
"ICE-GL-AN-001"
|
||||
),
|
||||
skill!(
|
||||
"ZZ-QW-ROLE-CAUSAL-ARCHITECTURE-001.json",
|
||||
"zhizhi",
|
||||
"ICE-GL-ZHI∞",
|
||||
"SYS-ZZ",
|
||||
"PER-QW001"
|
||||
),
|
||||
skill!(
|
||||
"CE-EED-MANJU-PRODUCTION-001.json",
|
||||
"canger",
|
||||
"TCS-CL-0009",
|
||||
"SYS-GLW-PTS-0001",
|
||||
"ICE-BB-0004"
|
||||
),
|
||||
skill!(
|
||||
"CE-EED-CAUSAL-PIPELINE-DIAGNOSTIC-001.json",
|
||||
"canger",
|
||||
"TCS-CL-0009",
|
||||
"SYS-GLW-PTS-0001",
|
||||
"ICE-BB-0004"
|
||||
),
|
||||
];
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
|
|
@ -123,6 +151,7 @@ pub fn registered_initial_identity(
|
|||
match (username.as_str(), session.domain.as_str()) {
|
||||
("bingshuo", "FIFTH_DOMAIN") => Some(identity("ICE-GL∞", "冰朔", "ICE-CH-ZC001")),
|
||||
("zhizhi", "FIFTH_DOMAIN") => Some(identity("ICE-GL-ZHI∞", "之之", "SYS-ZZ")),
|
||||
("canger", "FIFTH_DOMAIN") => Some(identity("TCS-CL-0009", "苍耳", "SYS-GLW-PTS-0001")),
|
||||
("awen", "MAIN_DOMAIN") => Some(identity("TCS-GL-0016∞", "Awen", "SYS-AW")),
|
||||
("huaer", "BRANCH_DOMAIN") => Some(identity("TCS-GL-0005∞", "花尔", "SYS-HE")),
|
||||
("yeye", "ZERO_DOMAIN") => Some(identity("TCS-GL-0006∞", "页页", "SYS-YY")),
|
||||
|
|
@ -374,7 +403,11 @@ fn view(skill: &BundledSkill, pack: &Value, bound: bool) -> Result<PersonalSkill
|
|||
owner_human_anchor: string("owner_human_anchor")?,
|
||||
channel_number: skill.channel_number.into(),
|
||||
custodian_persona_id: string("custodian_persona_id")?,
|
||||
runtime_state: if bound {
|
||||
runtime_state: if pack.get("skill_id").and_then(Value::as_str)
|
||||
== Some("ZZ-QW-ROLE-CAUSAL-ARCHITECTURE-001")
|
||||
{
|
||||
"INSTALLED_PRIVATE_CANDIDATE_NOT_EXECUTABLE_REGISTRATION_PENDING"
|
||||
} else if bound {
|
||||
"READY_FOR_PERSONA_JUDGMENT"
|
||||
} else {
|
||||
"INSTALLED_NOT_BOUND"
|
||||
|
|
@ -436,7 +469,7 @@ mod tests {
|
|||
#[test]
|
||||
fn every_current_pack_is_private_and_channel_scoped_while_shiyu_is_deferred() {
|
||||
validate_contract().unwrap();
|
||||
assert_eq!(SKILLS.len(), 9);
|
||||
assert_eq!(SKILLS.len(), 13);
|
||||
assert!(!SKILLS.iter().any(|skill| skill.channel_number == "SYS-SY"));
|
||||
for skill in SKILLS {
|
||||
validate_pack(skill).unwrap();
|
||||
|
|
@ -454,4 +487,27 @@ mod tests {
|
|||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn canger_and_zhizhi_closures_preserve_subject_and_admission_boundaries() {
|
||||
let eed = SKILLS
|
||||
.iter()
|
||||
.filter(|skill| skill.custodian_persona_id == "ICE-BB-0004")
|
||||
.collect::<Vec<_>>();
|
||||
assert_eq!(eed.len(), 2);
|
||||
assert!(eed.iter().all(|skill| {
|
||||
skill.account == "canger"
|
||||
&& skill.owner_human_anchor == "TCS-CL-0009"
|
||||
&& skill.channel_number == "SYS-GLW-PTS-0001"
|
||||
}));
|
||||
assert!(!SKILLS
|
||||
.iter()
|
||||
.any(|skill| skill.custodian_persona_id == "ICE-GL-CA001"));
|
||||
assert!(SKILLS
|
||||
.iter()
|
||||
.any(|skill| skill.file_name == "ZZ-AN-SOURCE-FACT-CLOSURE-001.json"));
|
||||
assert!(SKILLS
|
||||
.iter()
|
||||
.any(|skill| skill.file_name == "ZZ-QW-ROLE-CAUSAL-ARCHITECTURE-001.json"));
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in a new issue