@haaaiawd/second-nature 0.1.23 → 0.1.24

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@haaaiawd/second-nature",
-  "version": "0.1.23",
+  "version": "0.1.24",
   "description": "OpenClaw native plugin with synchronous registration, a packaged runtime artifact, and operator-facing status/explain flows.",
   "keywords": [
     "openclaw",

package/runtime/cli/index.js

@@ -8,6 +8,51 @@ import { createCliReadModels, } from "./read-models/index.js";
 import { resolvePackagedRuntime } from "./runtime/runtime-artifact-boundary.js";
 import { createRuntimeDecisionRecorder, } from "../observability/services/runtime-decision-recorder.js";
 import { createConnectorExecutorAdapter, } from "../connectors/services/connector-executor-adapter.js";
+import { DynamicConnectorRegistry, createRegistrySnapshotStore, } from "../connectors/registry/index.js";
+/** Built-in connector manifests for DynamicConnectorRegistry. */
+const BUILT_IN_CONNECTOR_MANIFESTS = [
+    {
+        schemaVersion: "sn.connector.v1",
+        platformId: "moltbook",
+        displayName: "Moltbook",
+        family: "social_community",
+        capabilities: [
+            { id: "feed.read" },
+            { id: "post.publish" },
+            { id: "comment.reply" },
+        ],
+        runner: { kind: "declarative_http" },
+        credentials: [{ type: "api_key", required: true }],
+        sourceRefPolicy: { minSourceRefs: 1 },
+    },
+    {
+        schemaVersion: "sn.connector.v1",
+        platformId: "evomap",
+        displayName: "EvoMap",
+        family: "agent_network",
+        capabilities: [
+            { id: "agent.register" },
+            { id: "work.discover" },
+        ],
+        runner: { kind: "declarative_http" },
+        credentials: [{ type: "api_key", required: true }],
+        sourceRefPolicy: { minSourceRefs: 1 },
+    },
+    {
+        schemaVersion: "sn.connector.v1",
+        platformId: "agent-world",
+        displayName: "Agent World",
+        family: "agent_network",
+        capabilities: [
+            { id: "feed.read" },
+            { id: "work.discover" },
+            { id: "task.claim" },
+        ],
+        runner: { kind: "declarative_http" },
+        credentials: [{ type: "api_key", required: true }],
+        sourceRefPolicy: { minSourceRefs: 1 },
+    },
+];
 export function createCliRuntimeDeps(overrides = {}) {
     const stateDb = overrides.stateDb ?? createStateDatabase();
     const observabilityDb = overrides.observabilityDb ?? createObservabilityDatabase();
@@ -26,6 +71,11 @@ export function createCliRuntimeDeps(overrides = {}) {
             stateDb,
             observabilityDb,
         });
+    const registry = overrides.registry ??
+        new DynamicConnectorRegistry({
+            builtInManifests: BUILT_IN_CONNECTOR_MANIFESTS,
+            snapshotStore: createRegistrySnapshotStore(),
+        });
     return {
         stateDb,
         observabilityDb,
@@ -34,6 +84,7 @@ export function createCliRuntimeDeps(overrides = {}) {
         actionBridge,
         runtimeRecorder,
         connectorExecutor,
+        registry,
     };
 }
 export function createCommandRouter(options = {}) {
@@ -47,6 +98,7 @@ export function createCommandRouter(options = {}) {
         workspaceRoot: process.cwd(),
         observabilityDb: runtime.observabilityDb,
         connectorExecutor: runtime.connectorExecutor,
+        registry: runtime.registry,
     });
     const commands = createCliCommands({
         readModels: runtime.readModels,

package/runtime/connectors/agent-network/agent-world/adapter.d.ts

@@ -0,0 +1,11 @@
+import type { ConnectorRequest, ExecutionPlan, RawAttempt } from "../../base/contract.js";
+export interface AgentWorldApiClient {
+    readFeed(payload: Record<string, unknown>, apiKey: string): Promise<unknown>;
+    discoverWork(payload: Record<string, unknown>, apiKey: string): Promise<unknown>;
+    claimTask(payload: Record<string, unknown>, apiKey: string): Promise<unknown>;
+}
+export declare function createAgentWorldRunner(input: {
+    apiClient: AgentWorldApiClient;
+}): {
+    run(plan: ExecutionPlan, request: ConnectorRequest): Promise<RawAttempt>;
+};

package/runtime/connectors/agent-network/agent-world/adapter.js

@@ -0,0 +1,58 @@
+export function createAgentWorldRunner(input) {
+    const { apiClient } = input;
+    return {
+        async run(plan, request) {
+            const started = Date.now();
+            try {
+                const apiKey = request.payload?.apiKey ?? "";
+                if (!apiKey) {
+                    return {
+                        platformId: request.platformId,
+                        channel: plan.channel,
+                        latencyMs: Date.now() - started,
+                        success: false,
+                        error: {
+                            code: "auth_failure",
+                            detail: "api_key_required_for_agent_world",
+                        },
+                    };
+                }
+                let result;
+                if (plan.intent === "feed.read") {
+                    result = await apiClient.readFeed(request.payload, String(apiKey));
+                }
+                else if (plan.intent === "work.discover") {
+                    result = await apiClient.discoverWork(request.payload, String(apiKey));
+                }
+                else if (plan.intent === "task.claim") {
+                    result = await apiClient.claimTask(request.payload, String(apiKey));
+                }
+                else {
+                    throw { code: "protocol_mismatch", detail: `unsupported agent-world intent: ${plan.intent}` };
+                }
+                return {
+                    platformId: request.platformId,
+                    channel: plan.channel,
+                    latencyMs: Date.now() - started,
+                    degraded: plan.channel === "skill",
+                    success: true,
+                    payload: {
+                        capability: request.intent,
+                        channel: plan.channel,
+                        data: result,
+                    },
+                };
+            }
+            catch (error) {
+                return {
+                    platformId: request.platformId,
+                    channel: plan.channel,
+                    latencyMs: Date.now() - started,
+                    degraded: plan.channel === "skill",
+                    success: false,
+                    error,
+                };
+            }
+        },
+    };
+}

package/runtime/connectors/agent-network/agent-world/index.d.ts

@@ -0,0 +1,2 @@
+export { agentWorldManifest } from "./manifest.js";
+export { createAgentWorldRunner, type AgentWorldApiClient } from "./adapter.js";

package/runtime/connectors/agent-network/agent-world/index.js

@@ -0,0 +1,2 @@
+export { agentWorldManifest } from "./manifest.js";
+export { createAgentWorldRunner } from "./adapter.js";

package/runtime/connectors/agent-network/agent-world/manifest.d.ts

@@ -0,0 +1,2 @@
+import type { ConnectorManifest } from "../../base/manifest.js";
+export declare const agentWorldManifest: ConnectorManifest;

package/runtime/connectors/agent-network/agent-world/manifest.js

@@ -0,0 +1,7 @@
+export const agentWorldManifest = {
+    platformId: "agent-world",
+    supportedCapabilities: ["feed.read", "work.discover", "task.claim"],
+    channelPriority: ["api_rest", "a2a", "skill"],
+    credentialTypes: ["api_key"],
+    degradedChannels: ["skill"],
+};

package/runtime/connectors/services/connector-executor-adapter.js

@@ -5,8 +5,10 @@ import { createConnectorPolicyLayer } from "../base/policy-layer.js";
 import { InMemoryEffectCommitLedger } from "../base/execution-policy.js";
 import { moltbookManifest } from "../social-community/moltbook/manifest.js";
 import { evomapManifest } from "../agent-network/evomap/manifest.js";
+import { agentWorldManifest } from "../agent-network/agent-world/manifest.js";
 import { createMoltbookApiClient } from "../social-community/moltbook/api-client.js";
 import { createMoltbookRunner } from "../social-community/moltbook/adapter.js";
+import { createAgentWorldRunner } from "../agent-network/agent-world/adapter.js";
 import { ExecutionTelemetry } from "../../observability/services/execution-telemetry.js";
 import { createCredentialVault } from "../../storage/services/credential-vault.js";
 import { createCredentialRouteContextPort } from "./credential-route-context.js";
@@ -74,6 +76,52 @@ function createAdaptiveExecutionRunner(vault) {
                     },
                 };
             }
+            if (platformId === "agent-world") {
+                const baseUrl = process.env.SECOND_NATURE_AGENT_WORLD_BASE_URL;
+                if (!baseUrl) {
+                    return {
+                        platformId,
+                        channel: request.preferredChannel ?? "api_rest",
+                        latencyMs: Date.now() - started,
+                        success: false,
+                        error: {
+                            code: "configuration_missing",
+                            detail: "SECOND_NATURE_AGENT_WORLD_BASE_URL not set",
+                        },
+                    };
+                }
+                const runner = createAgentWorldRunner({
+                    apiClient: {
+                        async readFeed(payload, _apiKey) {
+                            const resp = await fetch(`${baseUrl}/api/v1/feed`, {
+                                headers: { "Authorization": `Bearer ${_apiKey}`, "Content-Type": "application/json" },
+                            });
+                            if (!resp.ok)
+                                throw { code: "api_error", detail: `agent-world feed: ${resp.status}` };
+                            return resp.json();
+                        },
+                        async discoverWork(payload, _apiKey) {
+                            const resp = await fetch(`${baseUrl}/api/v1/work`, {
+                                headers: { "Authorization": `Bearer ${_apiKey}`, "Content-Type": "application/json" },
+                            });
+                            if (!resp.ok)
+                                throw { code: "api_error", detail: `agent-world work: ${resp.status}` };
+                            return resp.json();
+                        },
+                        async claimTask(payload, _apiKey) {
+                            const resp = await fetch(`${baseUrl}/api/v1/tasks/${payload.taskId ?? "unknown"}/claim`, {
+                                method: "POST",
+                                headers: { "Authorization": `Bearer ${_apiKey}`, "Content-Type": "application/json" },
+                                body: JSON.stringify(payload),
+                            });
+                            if (!resp.ok)
+                                throw { code: "api_error", detail: `agent-world claim: ${resp.status}` };
+                            return resp.json();
+                        },
+                    },
+                });
+                return runner.run(_plan, request);
+            }
             return {
                 platformId,
                 channel: request.preferredChannel ?? "api_rest",
@@ -92,6 +140,7 @@ export function createConnectorExecutorAdapter(options) {
     const registry = new CapabilityContractRegistry();
     registry.register({ ...moltbookManifest });
     registry.register({ ...evomapManifest });
+    registry.register({ ...agentWorldManifest });
     const routeContextPort = createCredentialRouteContextPort(vault);
     const routePlanner = new ConnectorRoutePlanner(registry, routeContextPort, new ChannelHealthStore());
     const telemetry = new ExecutionTelemetry(options.observabilityDb);

package/workspace-ops-bridge.js

@@ -47,6 +47,7 @@ export async function openWorkspaceOpsBridge(workspaceRoot) {
             state: stateDb,
             workspaceRoot: resolvedRoot,
             connectorExecutor: deps.connectorExecutor,
+            registry: deps.registry,
         });
         const commands = commandsMod.createCliCommands({
             readModels: deps.readModels,