@tokensmind/agent-network 0.1.0 → 0.1.3

package/src/agent-actions.js

@@ -1,12 +1,28 @@
 import { actionFailure, requireInput } from './action-errors.js';
-import { optionalLimit, text } from './action-validation.js';
+import { text } from './action-validation.js';
+
+function profileTags(value) {
+  if (value === undefined || value === null) return [];
+  if (!Array.isArray(value) || value.some((item) => typeof item !== 'string')) {
+    requireInput(['agent.tags'], 'agent.tags must be an array of strings.');
+  }
+  return value;
+}
 
 export async function searchAgents(context) {
   const query = text(context.input.query);
-  const limit = optionalLimit(context.input.limit);
-  const params = new URLSearchParams({ limit: String(limit) });
-  if (query) params.set('q', query);
-  return context.get(`/agent-network-api/agents?${params}`);
+  if (!query) requireInput(['query']);
+  try {
+    return await context.get(`/agent-network-api/agents?q=${encodeURIComponent(query)}`);
+  } catch (error) {
+    const code = error?.code;
+    if (!['AGENT_REQUIRED', 'AGENT_PROFILE_REQUIRED'].includes(code)) throw error;
+    actionFailure(
+      code,
+      'Create the account Agent profile with ensure_agent before searching.',
+      { nextOperation: 'ensure_agent' },
+    );
+  }
 }
 
 export async function getMyAgent(context) {
@@ -25,7 +41,21 @@ function profileInput(input) {
   const name = text(profile.name);
   const description = text(profile.description);
   if (!name || !description) requireInput(['agent.name', 'agent.description']);
-  return { name, description };
+  return { name, description, tags: profileTags(profile.tags) };
+}
+
+function profileUpdateInput(input, existing) {
+  const profile = input.agent || input.profile || {};
+  const hasName = Object.hasOwn(profile, 'name');
+  const hasDescription = Object.hasOwn(profile, 'description');
+  const hasTags = Object.hasOwn(profile, 'tags');
+  if (!hasName && !hasDescription && !hasTags) {
+    requireInput(['agent.name', 'agent.description', 'agent.tags']);
+  }
+  const name = text(hasName ? profile.name : existing.name);
+  const description = text(hasDescription ? profile.description : existing.description);
+  if (!name || !description) requireInput(['agent.name', 'agent.description']);
+  return { name, description, tags: profileTags(hasTags ? profile.tags : existing.tags) };
 }
 
 export async function ensureAgent(context) {
@@ -42,3 +72,20 @@ export async function ensureAgent(context) {
   }
   return { agent: result.agent, created: true };
 }
+
+export async function updateAgent(context) {
+  const existing = await getMyAgent(context);
+  if (!existing) {
+    actionFailure('AGENT_PROFILE_REQUIRED', 'Create the account Agent profile before updating it.');
+  }
+  const result = await context.mutate({
+    method: 'PATCH',
+    path: `/agent-network-api/agents/${encodeURIComponent(existing.id)}`,
+    body: profileUpdateInput(context.input, existing),
+    label: 'agent:update',
+  });
+  if (!result?.agent) {
+    actionFailure('AGENT_UPDATE_PROTOCOL_ERROR', 'Agent update returned no Agent.');
+  }
+  return { agent: result.agent, updated: true };
+}

package/src/api-client.js

@@ -12,7 +12,7 @@ const CLIENT_VERSION = '0.1.0';
 
 export class AuthorizationRequiredError extends Error {
   constructor(verificationUrl) {
-    super('Complete Agent Network authorization in the browser, then retry the action.');
+    super('Default browser handoff failed; resume the pending action to continue polling.');
     this.name = 'AuthorizationRequiredError';
     this.status = 'authorization_required';
     this.verificationUrl = verificationUrl;
@@ -54,7 +54,19 @@ export function createActionApi(options = {}) {
     baseUrl, stateDir, platform, env, homeDir, hostname, browser, http, store, writeEvent,
   } = resolveOptions(options);
   const origin = normalizeBaseUrl(baseUrl);
-  const resolvedStore = store || createCredentialStore({ stateDir, origin, platform, env, homeDir });
+  const resolvedStore = store || createCredentialStore({
+    stateDir,
+    origin,
+    platform,
+    env,
+    homeDir,
+    onFallback: ({ backend, directory, reason }) => writeEvent({
+      event: 'credential_store_fallback',
+      backend,
+      directory,
+      reason,
+    }),
+  });
   const workflowStore = createWorkflowStore({ stateDir, origin, platform, homeDir });
   const connector = createConnector({
     baseUrl: origin,

package/src/contact-action.js

@@ -19,7 +19,7 @@ async function resolveTarget(context) {
   const name = text(target.name);
   if (!name) requireInput(['target.id or target.name']);
   const agents = await context.get(
-    `/agent-network-api/agents?q=${encodeURIComponent(name)}&limit=20`,
+    `/agent-network-api/agents?q=${encodeURIComponent(name)}`,
   );
   if (!Array.isArray(agents) || agents.length === 0) {
     actionFailure('TARGET_AGENT_NOT_FOUND', `No Agent matched "${name}".`);

package/src/index.js

@@ -12,9 +12,11 @@ const ACTION_SCHEMA = {
     operation: {
       type: 'string',
       enum: [
-        'abandon_action', 'search_agents', 'get_my_agent', 'ensure_agent', 'contact_agent',
+        'abandon_action', 'search_agents', 'get_my_agent', 'ensure_agent', 'update_agent',
+        'contact_agent',
         'list_inbox', 'get_conversation', 'reply', 'mark_read',
         'withdraw_message', 'block_agent', 'unblock_agent', 'report', 'appeal',
+        'get_memory_settings', 'propose_memory', 'list_memories', 'delete_memory',
       ],
     },
     input: {
@@ -57,7 +59,7 @@ function getExecutor(config) {
 }
 
 export default defineToolPlugin({
-  id: 'tokensmind-agent-network-runtime',
+  id: 'tokensmind-agent-network',
   name: 'TokensMind Agent Network Runtime',
   description: 'Run high-level Agent Network operations with private authorization.',
   configSchema: CONFIG_SCHEMA,

package/src/memory-actions.js

@@ -0,0 +1,112 @@
+import { actionFailure, requireInput } from './action-errors.js';
+import { getMyAgent } from './agent-actions.js';
+import { isObject, optionalLimit, requiredId, requiredText, text } from './action-validation.js';
+
+const MEMORY_KINDS = new Set(['agent_experience', 'matching_preference']);
+const MEMORY_POLARITIES = new Set(['negative', 'positive']);
+const MEMORY_SCOPES = new Set(['contextual', 'global']);
+// platform_event 由服务端独占写入，客户端提交会被拒绝。
+const MEMORY_SOURCES = new Set(['model_inferred', 'user_explicit']);
+const MEMORY_STATUSES = new Set(['active', 'deleted', 'pending_review', 'rejected']);
+const MAX_INFERRED_CONFIDENCE = 0.6;
+
+function requireChoice(input, field, allowed) {
+  const value = text(input?.[field]).toLowerCase();
+  if (!allowed.has(value)) requireInput([field], `${field} has an unsupported value.`);
+  return value;
+}
+
+function optionalConfidence(value, sourceType) {
+  if (value === undefined || value === null || value === '') {
+    return sourceType === 'model_inferred' ? MAX_INFERRED_CONFIDENCE : 1;
+  }
+  const confidence = Number(value);
+  const inferredLimitExceeded = sourceType === 'model_inferred'
+    && confidence > MAX_INFERRED_CONFIDENCE;
+  if (!Number.isFinite(confidence) || confidence <= 0 || confidence > 1 || inferredLimitExceeded) {
+    requireInput(['confidence'], 'confidence must be above 0 and no more than 0.6 for inferred memory.');
+  }
+  return confidence;
+}
+
+async function ownedAgent(context) {
+  const agent = await getMyAgent(context);
+  if (!agent) actionFailure('AGENT_PROFILE_REQUIRED', 'Create the account Agent profile first.');
+  return agent;
+}
+
+function agentPath(agentId, suffix) {
+  return `/agent-network-api/agents/${encodeURIComponent(agentId)}/${suffix}`;
+}
+
+function optionalText(input, field) {
+  return Object.hasOwn(input, field) ? text(input[field]) || null : null;
+}
+
+function memoryBody(input) {
+  if (!isObject(input)) requireInput(['input']);
+  const sourceType = requireChoice(input, 'sourceType', MEMORY_SOURCES);
+  const scope = input.scope ? requireChoice(input, 'scope', MEMORY_SCOPES) : 'contextual';
+  const contextText = scope === 'global' ? '' : requiredText(input, 'contextText');
+  return {
+    clientMemoryId: requiredText(input, 'clientMemoryId'),
+    confidence: optionalConfidence(input.confidence, sourceType),
+    contextText,
+    conversationId: optionalText(input, 'conversationId'),
+    expiresAt: optionalText(input, 'expiresAt'),
+    kind: requireChoice(input, 'kind', MEMORY_KINDS),
+    polarity: requireChoice(input, 'polarity', MEMORY_POLARITIES),
+    requirementId: optionalText(input, 'requirementId'),
+    scope,
+    sourceType,
+    statement: requiredText(input, 'statement'),
+    targetAgentId: optionalText(input, 'targetAgentId'),
+  };
+}
+
+function listQuery(input) {
+  const params = new URLSearchParams({ limit: String(optionalLimit(input.limit)) });
+  if (input.offset !== undefined) {
+    const offset = Number(input.offset);
+    if (!Number.isInteger(offset) || offset < 0) requireInput(['offset']);
+    params.set('offset', String(offset));
+  }
+  if (input.status) params.set('status', requireChoice(input, 'status', MEMORY_STATUSES));
+  return params.toString();
+}
+
+export async function getMemorySettings(context) {
+  const agent = await ownedAgent(context);
+  return context.get(agentPath(agent.id, 'memory-settings'));
+}
+
+export async function proposeMemory(context) {
+  const body = memoryBody(context.input);
+  const agent = await ownedAgent(context);
+  const settings = await context.get(agentPath(agent.id, 'memory-settings'));
+  if (settings?.collectionEnabled !== true) {
+    actionFailure('MEMORY_COLLECTION_DISABLED', 'Memory collection is disabled for this Agent.');
+  }
+  return context.mutate({
+    method: 'POST',
+    path: agentPath(agent.id, 'memories'),
+    body,
+    label: 'memory:propose',
+  });
+}
+
+export async function listMemories(context) {
+  const query = listQuery(context.input);
+  const agent = await ownedAgent(context);
+  return context.get(`${agentPath(agent.id, 'memories')}?${query}`);
+}
+
+export async function deleteMemory(context) {
+  const memoryId = requiredId(context.input, 'memoryId');
+  const agent = await ownedAgent(context);
+  return context.mutate({
+    method: 'DELETE',
+    path: `${agentPath(agent.id, 'memories')}/${encodeURIComponent(memoryId)}`,
+    label: 'memory:delete',
+  });
+}

package/src/runtime/connector.js

@@ -8,7 +8,6 @@ import {
 } from './deviceAuthorization.js';
 import {
   buildBusinessUrl,
-  isPublicDiscoveryRequest,
   validateBusinessRequest,
 } from './requestPolicy.js';
 
@@ -47,15 +46,6 @@ function assertActiveCredential(active) {
   return active;
 }
 
-function authorizationPending(verificationUrl) {
-  const error = new Error(
-    'Complete Agent Network authorization in the browser, then retry the action.',
-  );
-  error.status = 'authorization_required';
-  error.verificationUrl = verificationUrl;
-  return error;
-}
-
 async function executeBusinessRequest({ operation, token, baseUrl, http, signal }) {
   return http.request({
     url: buildBusinessUrl(baseUrl, operation.path),
@@ -90,7 +80,6 @@ async function authorize({ operation, store, browser, baseUrl, http, client, sig
       pending = await createRemoteAuthorization({ pending, baseUrl, http, client, signal });
       await store.write('pending', pending);
       await browser.open(pending.authorization.verificationUrl);
-      throw authorizationPending(pending.authorization.verificationUrl);
     }
     if (pending.phase === 'authorizing') {
       await waitForApproval({ pending, baseUrl, http, signal });
@@ -131,6 +120,11 @@ function isInvalidAgentCredential(error) {
     ].includes(error.code);
 }
 
+function requiresAuthorization(error) {
+  return error instanceof AgentNetworkHttpError
+    && (error.status === 401 || isInvalidAgentCredential(error));
+}
+
 async function executeAndFinalize({ pending, active, dependencies }) {
   assertActiveCredential(active);
   try {
@@ -144,7 +138,7 @@ async function executeAndFinalize({ pending, active, dependencies }) {
   } catch (error) {
     if (error instanceof AgentNetworkHttpError && error.status < 500 && error.status !== 429) {
       await dependencies.store.remove('pending');
-      if (isInvalidAgentCredential(error)) await dependencies.store.remove('active');
+      if (requiresAuthorization(error)) await dependencies.store.remove('active');
     }
     throw error;
   }
@@ -170,7 +164,7 @@ export function createConnector({ store, browser, baseUrl, http, client }) {
     try {
       return await executeBusinessRequest({ operation, token: active.token, baseUrl, http, signal });
     } catch (error) {
-      if (!isInvalidAgentCredential(error)) throw error;
+      if (!requiresAuthorization(error)) throw error;
       await store.remove('active');
       return authorizeAndExecute(operation, signal);
     }
@@ -181,15 +175,10 @@ export function createConnector({ store, browser, baseUrl, http, client }) {
     const normalized = validateBusinessRequest(params);
     const operation = { ...normalized, body: params.body };
     const reauthorize = params.reauthorize === true;
+
     const pending = await store.read('pending');
     const active = await store.read('active');
-
     if (pending) return resumePending(pending, operation, signal);
-
-    if (isPublicDiscoveryRequest(operation) && !reauthorize) {
-      return executeBusinessRequest({ operation, baseUrl, http, signal });
-    }
-
     if (!active || reauthorize) return authorizeAndExecute(operation, signal);
     return executeWithActive(operation, active, signal);
   }

package/src/runtime/credentialStore.js

@@ -6,7 +6,10 @@ import {
   originNamespace,
   resolvePortableStateDir,
 } from './portableStore.js';
-import { resolveSystemCredentialStore } from './systemCredentialStore.js';
+import {
+  resolveSystemCredentialStore,
+  SystemCredentialStoreError,
+} from './systemCredentialStore.js';
 
 const RECORD_NAMES = Object.freeze(['instance', 'pending', 'active']);
 
@@ -122,6 +125,53 @@ function createFileStores({ directories, origin, platform, env, homeDir, fs, ran
   }));
 }
 
+async function validateSystemRecords(systemStore) {
+  for (const name of RECORD_NAMES) await systemStore.read(name);
+}
+
+async function initializeStore({
+  systemStore, fallback, fallbackDirectory, legacyDirectories, storeOptions, onFallback,
+}) {
+  const recordDirectory = path.join(
+    fallbackDirectory, originNamespace(storeOptions.origin),
+  );
+  const legacySources = createFileStores({
+    ...storeOptions, directories: legacyDirectories,
+  });
+  if (!systemStore) {
+    onFallback({
+      backend: null,
+      directory: recordDirectory,
+      reason: 'No supported system credential store is available',
+    });
+    await migrateCredentialStores({ target: fallback, sources: legacySources });
+    return fallback;
+  }
+  try {
+    if (typeof systemStore.verifyAvailability !== 'function') {
+      throw new SystemCredentialStoreError(
+        'System credential store does not support availability verification',
+      );
+    }
+    await systemStore.verifyAvailability();
+    await validateSystemRecords(systemStore);
+    const sources = createFileStores({
+      ...storeOptions, directories: [fallbackDirectory, ...legacyDirectories],
+    });
+    await migrateCredentialStores({ target: systemStore, sources });
+    return systemStore;
+  } catch (error) {
+    if (!(error instanceof SystemCredentialStoreError)) throw error;
+    onFallback({
+      backend: systemStore.backend,
+      directory: recordDirectory,
+      reason: error.message,
+    });
+    await migrateCredentialStores({ target: fallback, sources: legacySources });
+    return fallback;
+  }
+}
+
 export function createCredentialStore({
   stateDir,
   origin,
@@ -133,6 +183,7 @@ export function createCredentialStore({
   secureStore,
   resolveSecureStore = resolveSystemCredentialStore,
   run,
+  onFallback = () => {},
 } = {}) {
   if (stateDir) {
     return createPortableStore({ stateDir, origin, platform, env, homeDir, fs, randomId });
@@ -147,16 +198,14 @@ export function createCredentialStore({
         platform, namespace: originNamespace(origin), env, fs, run,
       })
       : secureStore;
-    const target = systemStore || fallback;
-    const sourceDirectories = [
-      ...(systemStore ? [fallbackDirectory] : []),
-      ...resolveLegacyStateDirs({ platform, env, homeDir }),
-    ];
-    const sources = createFileStores({
-      directories: [...new Set(sourceDirectories)],
-      origin, platform, env, homeDir, fs, randomId,
+    const legacyDirectories = resolveLegacyStateDirs({ platform, env, homeDir });
+    return initializeStore({
+      systemStore,
+      fallback,
+      fallbackDirectory,
+      legacyDirectories: [...new Set(legacyDirectories)],
+      storeOptions: { origin, platform, env, homeDir, fs, randomId },
+      onFallback,
     });
-    await migrateCredentialStores({ target, sources });
-    return target;
   });
 }

package/src/runtime/requestPolicy.js

@@ -1,8 +1,6 @@
 import { INTERNAL_PATH_PATTERNS, MUTATION_METHODS } from './constants.js';
 
 const SUPPORTED_METHODS = new Set(['GET', 'POST', 'PATCH', 'DELETE']);
-const PUBLIC_AGENT_DIRECTORY_PATH = '/agent-network-api/agents';
-
 export function normalizeBaseUrl(value) {
   const url = new URL(value);
   if (!['http:', 'https:'].includes(url.protocol)) {
@@ -44,12 +42,3 @@ export function buildBusinessUrl(baseUrl, path) {
   }
   return url.toString();
 }
-
-export function isPublicDiscoveryRequest({ method, path }) {
-  if (method !== 'GET') return false;
-  const url = new URL(path, 'https://tokensmind.invalid');
-  const mineRequested = [...url.searchParams.entries()]
-    .some(([key, value]) => key === 'mine' && value === '1');
-  return url.pathname === PUBLIC_AGENT_DIRECTORY_PATH
-    && !mineRequested;
-}