@noopolis/daimon 0.1.1 → 0.1.2

package/dist/pi/wakeAcceptanceSchema.d.ts

@@ -0,0 +1,75 @@
+import type { WakeEvent } from "../core/types.js";
+export declare const WAKE_ACCEPTANCE_VERSION: "noopolis.wake-acceptance.v1";
+export declare const WAKE_ACCEPTANCE_FILE: "state.v1.json";
+export declare const WAKE_ACCEPTANCE_COMPLETED_TOMBSTONES = 512;
+export declare const WAKE_ACCEPTANCE_FILE_BYTES_MAX = 1048576;
+export declare const WAKE_ACCEPTANCE_FIELD_BYTES_MAX = 512;
+export type WakeAcceptanceState = "accepted" | "invoking" | "completed" | "incomplete";
+export type WakeAcceptanceSafeErrorCode = "wake_delivery_conflict" | "wake_delivery_incomplete" | "wake_acceptance_store_corrupt" | "wake_delivery_invalid";
+export declare class WakeAcceptanceError extends Error {
+    readonly code: WakeAcceptanceSafeErrorCode;
+    constructor(code: WakeAcceptanceSafeErrorCode);
+}
+export interface WakeAcceptanceAttempt {
+    bodySha256: string;
+    contextId: string;
+    digest: string;
+    eventId: string;
+    identity: string;
+    kind: string;
+    sender: string;
+    target: string;
+}
+export interface WakeAcceptanceRecord {
+    body_sha256: string;
+    context_id: string;
+    digest: string;
+    event_id: string;
+    identity: string;
+    kind: string;
+    sender: string;
+    state: WakeAcceptanceState;
+    sequence: number;
+    target: string;
+}
+export interface WakeAcceptanceStoreState {
+    version: string;
+    run_id: string;
+    agent_id: string;
+    next_sequence: number;
+    records: WakeAcceptanceRecord[];
+}
+export declare const wakeAcceptanceIdentity: (input: {
+    runId: string;
+    agentId: string;
+    eventId: string;
+}) => string;
+export declare const wakeAcceptanceDigest: (input: {
+    bodySha256: string;
+    contextId: string;
+    eventId: string;
+    kind: string;
+    sender: string;
+    target: string;
+}) => string;
+export declare const candidateFromDelivery: (input: {
+    event: WakeEvent;
+    runId: string;
+    trustedAgentId: string;
+}) => WakeAcceptanceAttempt;
+export declare const candidateFromEvent: (input: {
+    event: WakeEvent;
+    runId: string;
+    agentId: string;
+}) => WakeAcceptanceAttempt;
+export declare const parseWakeAcceptanceState: (raw: unknown, context: {
+    runId: string;
+    agentId: string;
+}) => WakeAcceptanceStoreState;
+export declare const emptyWakeAcceptanceState: (context: {
+    runId: string;
+    agentId: string;
+}) => WakeAcceptanceStoreState;
+export declare const pruneCompletedRecords: (records: WakeAcceptanceRecord[]) => WakeAcceptanceRecord[];
+export declare const serializeWakeAcceptanceState: (state: WakeAcceptanceStoreState) => string;
+//# sourceMappingURL=wakeAcceptanceSchema.d.ts.map

package/dist/pi/wakeAcceptanceSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wakeAcceptanceSchema.d.ts","sourceRoot":"","sources":["../../src/pi/wakeAcceptanceSchema.ts"],"names":[],"mappings":"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"}

package/dist/pi/wakeAcceptanceSchema.js

@@ -0,0 +1,265 @@
+import { createHash } from "node:crypto";
+export const WAKE_ACCEPTANCE_VERSION = "noopolis.wake-acceptance.v1";
+export const WAKE_ACCEPTANCE_FILE = "state.v1.json";
+export const WAKE_ACCEPTANCE_COMPLETED_TOMBSTONES = 512;
+export const WAKE_ACCEPTANCE_FILE_BYTES_MAX = 1_048_576;
+export const WAKE_ACCEPTANCE_FIELD_BYTES_MAX = 512;
+export class WakeAcceptanceError extends Error {
+    code;
+    constructor(code) {
+        super(code);
+        this.code = code;
+        this.name = "WakeAcceptanceError";
+    }
+}
+const UTF8 = "utf8";
+const IDENTITY_DOMAIN = "daimon.wake-acceptance.v1";
+const isObject = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+const exactKeys = (value, keys) => {
+    const current = Object.keys(value);
+    if (current.length !== keys.length) {
+        throw new WakeAcceptanceError("wake_acceptance_store_corrupt");
+    }
+    for (const key of keys) {
+        if (!Object.prototype.hasOwnProperty.call(value, key)) {
+            throw new WakeAcceptanceError("wake_acceptance_store_corrupt");
+        }
+    }
+};
+const assertInteger = (value, key, allowNegative = false) => {
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || (!allowNegative && value < 0)) {
+        throw new WakeAcceptanceError("wake_acceptance_store_corrupt");
+    }
+    return value;
+};
+const textMaxBytes = (value, maxBytes = WAKE_ACCEPTANCE_FIELD_BYTES_MAX) => Buffer.byteLength(value, UTF8) <= maxBytes;
+const assertText = (value, code, allowEmpty = false) => {
+    if (typeof value !== "string") {
+        throw new WakeAcceptanceError(code);
+    }
+    if (!allowEmpty && value.length === 0) {
+        throw new WakeAcceptanceError(code);
+    }
+    if (!textMaxBytes(value)) {
+        throw new WakeAcceptanceError(code);
+    }
+    return value;
+};
+const assertTextUnbounded = (value, code) => {
+    if (typeof value !== "string") {
+        throw new WakeAcceptanceError(code);
+    }
+    return value;
+};
+const assertObject = (value, code) => {
+    if (!isObject(value)) {
+        throw new WakeAcceptanceError(code);
+    }
+    return value;
+};
+const canonical = (left, right) => {
+    if (left.sequence !== right.sequence) {
+        return left.sequence - right.sequence;
+    }
+    return left.identity.localeCompare(right.identity);
+};
+const isHex64 = (value) => /^[0-9a-f]{64}$/u.test(value);
+const sha256 = (value) => createHash("sha256").update(value, UTF8).digest("hex");
+const identityPreimage = (input) => `${IDENTITY_DOMAIN}\0${input.runId}\0${input.agentId}\0${input.eventId}`;
+export const wakeAcceptanceIdentity = (input) => sha256(identityPreimage(input));
+export const wakeAcceptanceDigest = (input) => sha256(JSON.stringify({
+    body_sha256: input.bodySha256,
+    context_id: input.contextId,
+    event_id: input.eventId,
+    kind: input.kind,
+    sender: input.sender,
+    target: input.target
+}));
+const parseRecord = (raw) => {
+    exactKeys(raw, [
+        "body_sha256",
+        "context_id",
+        "digest",
+        "event_id",
+        "identity",
+        "kind",
+        "sender",
+        "state",
+        "sequence",
+        "target"
+    ]);
+    const body = assertText(raw.body_sha256, "wake_acceptance_store_corrupt");
+    const contextId = assertText(raw.context_id, "wake_acceptance_store_corrupt");
+    const digest = assertText(raw.digest, "wake_acceptance_store_corrupt");
+    const eventId = assertText(raw.event_id, "wake_acceptance_store_corrupt");
+    const identity = assertText(raw.identity, "wake_acceptance_store_corrupt");
+    const kind = assertText(raw.kind, "wake_acceptance_store_corrupt");
+    const sender = assertText(raw.sender, "wake_acceptance_store_corrupt");
+    const target = assertText(raw.target, "wake_acceptance_store_corrupt");
+    const state = assertText(raw.state, "wake_acceptance_store_corrupt");
+    const sequence = assertInteger(raw.sequence, "sequence");
+    if (state !== "accepted" && state !== "invoking" && state !== "completed" && state !== "incomplete") {
+        throw new WakeAcceptanceError("wake_acceptance_store_corrupt");
+    }
+    if (!isHex64(body) || !isHex64(digest) || !isHex64(identity)) {
+        throw new WakeAcceptanceError("wake_acceptance_store_corrupt");
+    }
+    return {
+        body_sha256: body,
+        context_id: contextId,
+        digest,
+        event_id: eventId,
+        identity,
+        kind,
+        sender,
+        state,
+        sequence,
+        target
+    };
+};
+export const candidateFromDelivery = (input) => {
+    const eventId = assertText(input.event.id, "wake_delivery_invalid");
+    const kind = assertText(input.event.kind, "wake_delivery_invalid");
+    if (kind !== "message") {
+        throw new WakeAcceptanceError("wake_delivery_invalid");
+    }
+    if (input.event.delivery === undefined) {
+        throw new WakeAcceptanceError("wake_delivery_invalid");
+    }
+    if (assertText(input.event.delivery.eventId, "wake_delivery_invalid") !== eventId) {
+        throw new WakeAcceptanceError("wake_delivery_invalid");
+    }
+    const sender = assertText(input.event.delivery.sender, "wake_delivery_invalid");
+    const target = assertText(input.event.delivery.target, "wake_delivery_invalid");
+    const contextId = assertText(input.event.delivery.contextId, "wake_delivery_invalid");
+    const from = assertText(input.event.from, "wake_delivery_invalid");
+    if (target !== input.trustedAgentId || from !== sender) {
+        throw new WakeAcceptanceError("wake_delivery_invalid");
+    }
+    const bodySha256 = sha256(assertTextUnbounded(input.event.text, "wake_delivery_invalid"));
+    return {
+        bodySha256,
+        contextId,
+        digest: wakeAcceptanceDigest({
+            bodySha256,
+            contextId,
+            eventId,
+            kind,
+            sender,
+            target
+        }),
+        eventId,
+        identity: wakeAcceptanceIdentity({ runId: input.runId, agentId: input.trustedAgentId, eventId }),
+        kind,
+        sender,
+        target
+    };
+};
+export const candidateFromEvent = (input) => candidateFromDelivery({
+    event: input.event,
+    runId: input.runId,
+    trustedAgentId: input.agentId
+});
+const parseState = (raw, context) => {
+    const root = assertObject(raw, "wake_acceptance_store_corrupt");
+    exactKeys(root, ["version", "run_id", "agent_id", "next_sequence", "records"]);
+    const version = assertText(root.version, "wake_acceptance_store_corrupt");
+    const runId = assertText(root.run_id, "wake_acceptance_store_corrupt");
+    const agentId = assertText(root.agent_id, "wake_acceptance_store_corrupt");
+    const nextSequence = assertInteger(root.next_sequence, "next_sequence");
+    if (version !== WAKE_ACCEPTANCE_VERSION || runId !== context.runId || agentId !== context.agentId) {
+        throw new WakeAcceptanceError("wake_acceptance_store_corrupt");
+    }
+    if (!Array.isArray(root.records)) {
+        throw new WakeAcceptanceError("wake_acceptance_store_corrupt");
+    }
+    const records = root.records.map((entry) => {
+        const parsed = parseRecord(assertObject(entry, "wake_acceptance_store_corrupt"));
+        if (parsed.kind !== "message") {
+            throw new WakeAcceptanceError("wake_acceptance_store_corrupt");
+        }
+        if (parsed.target !== context.agentId) {
+            throw new WakeAcceptanceError("wake_acceptance_store_corrupt");
+        }
+        const expectedIdentity = wakeAcceptanceIdentity({
+            runId,
+            agentId,
+            eventId: parsed.event_id
+        });
+        if (parsed.identity !== expectedIdentity) {
+            throw new WakeAcceptanceError("wake_acceptance_store_corrupt");
+        }
+        const expectedDigest = wakeAcceptanceDigest({
+            bodySha256: parsed.body_sha256,
+            contextId: parsed.context_id,
+            eventId: parsed.event_id,
+            kind: parsed.kind,
+            sender: parsed.sender,
+            target: parsed.target
+        });
+        if (parsed.digest !== expectedDigest) {
+            throw new WakeAcceptanceError("wake_acceptance_store_corrupt");
+        }
+        return parsed;
+    });
+    let completed = 0;
+    let previousSequence = 0;
+    const seenSequences = new Set();
+    const seenIdentities = new Set();
+    for (const record of records) {
+        if (record.sequence <= 0 || seenSequences.has(record.sequence)) {
+            throw new WakeAcceptanceError("wake_acceptance_store_corrupt");
+        }
+        if (record.sequence <= previousSequence) {
+            throw new WakeAcceptanceError("wake_acceptance_store_corrupt");
+        }
+        if (seenIdentities.has(record.identity)) {
+            throw new WakeAcceptanceError("wake_acceptance_store_corrupt");
+        }
+        if (record.sequence > nextSequence) {
+            throw new WakeAcceptanceError("wake_acceptance_store_corrupt");
+        }
+        seenSequences.add(record.sequence);
+        seenIdentities.add(record.identity);
+        if (record.state === "completed") {
+            completed += 1;
+        }
+        previousSequence = record.sequence;
+    }
+    if (records.length > 0 && previousSequence !== nextSequence) {
+        throw new WakeAcceptanceError("wake_acceptance_store_corrupt");
+    }
+    if (records.length === 0 && nextSequence !== 0) {
+        throw new WakeAcceptanceError("wake_acceptance_store_corrupt");
+    }
+    if (completed > WAKE_ACCEPTANCE_COMPLETED_TOMBSTONES) {
+        throw new WakeAcceptanceError("wake_acceptance_store_corrupt");
+    }
+    return {
+        version: WAKE_ACCEPTANCE_VERSION,
+        run_id: runId,
+        agent_id: agentId,
+        next_sequence: nextSequence,
+        records
+    };
+};
+export const parseWakeAcceptanceState = parseState;
+export const emptyWakeAcceptanceState = (context) => ({
+    version: WAKE_ACCEPTANCE_VERSION,
+    run_id: context.runId,
+    agent_id: context.agentId,
+    next_sequence: 0,
+    records: []
+});
+export const pruneCompletedRecords = (records) => {
+    const active = [...records].filter((record) => record.state !== "completed").sort(canonical);
+    const completed = [...records]
+        .filter((record) => record.state === "completed")
+        .sort(canonical);
+    if (completed.length > WAKE_ACCEPTANCE_COMPLETED_TOMBSTONES) {
+        const keep = completed.slice(completed.length - WAKE_ACCEPTANCE_COMPLETED_TOMBSTONES);
+        return [...active, ...keep].sort(canonical);
+    }
+    return [...active, ...completed].sort(canonical);
+};
+export const serializeWakeAcceptanceState = (state) => JSON.stringify(state);

package/dist/pi/wakeModes.d.ts

@@ -0,0 +1,9 @@
+import type { MemoryWakeMode, WakeMemoryContext } from "@noopolis/mneme";
+import type { WakeEvent } from "../core/types.js";
+export declare const wakeModeForEvent: (event: WakeEvent) => MemoryWakeMode;
+export declare const createAwakeThreadId: (memoryContext: WakeMemoryContext, agentId: string) => string;
+export declare const createDreamSessionKey: (event: WakeEvent) => string;
+export declare const createDreamThreadId: (sessionKey: string) => string;
+export declare const createDreamSessionDirectory: (runtimeHomePath: string, sessionKey: string) => string;
+export declare const formatDreamPrompt: (promptText: string, threadId: string) => string;
+//# sourceMappingURL=wakeModes.d.ts.map

package/dist/pi/wakeModes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wakeModes.d.ts","sourceRoot":"","sources":["../../src/pi/wakeModes.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAEzE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAElD,eAAO,MAAM,gBAAgB,GAAI,OAAO,SAAS,KAAG,cACR,CAAC;AAE7C,eAAO,MAAM,mBAAmB,GAAI,eAAe,iBAAiB,EAAE,SAAS,MAAM,KAAG,MACU,CAAC;AAEnG,eAAO,MAAM,qBAAqB,GAAI,OAAO,SAAS,KAAG,MACS,CAAC;AAEnE,eAAO,MAAM,mBAAmB,GAAI,YAAY,MAAM,KAAG,MAA+B,CAAC;AAEzF,eAAO,MAAM,2BAA2B,GAAI,iBAAiB,MAAM,EAAE,YAAY,MAAM,KAAG,MAC7B,CAAC;AAE9D,eAAO,MAAM,iBAAiB,GAAI,YAAY,MAAM,EAAE,UAAU,MAAM,KAAG,MAO7D,CAAC"}

package/dist/pi/wakeModes.js

@@ -0,0 +1,19 @@
+import { randomBytes } from "node:crypto";
+import path from "node:path";
+export const wakeModeForEvent = (event) => event.kind === "dream" ? "dream" : "awake";
+export const createAwakeThreadId = (memoryContext, agentId) => `${memoryContext.networkId ?? "local"}:${memoryContext.roomId ?? memoryContext.from ?? agentId}`;
+export const createDreamSessionKey = (event) => `${safeSessionPart(event.id)}-${randomBytes(4).toString("hex")}`;
+export const createDreamThreadId = (sessionKey) => `dream:${sessionKey}`;
+export const createDreamSessionDirectory = (runtimeHomePath, sessionKey) => path.join(runtimeHomePath, "sessions", "dream", sessionKey);
+export const formatDreamPrompt = (promptText, threadId) => [
+    "## Dream Mode",
+    "",
+    "This is a one-off memory consolidation session. Use Mneme tools to audit, summarize, promote, or retire memories with explicit evidence. Do not treat this as a normal chat reply.",
+    `dream_thread: ${threadId}`,
+    "",
+    promptText
+].join("\n");
+const safeSessionPart = (value) => {
+    const normalized = value.trim().replace(/[^A-Za-z0-9_.-]+/gu, "-").replace(/^-+|-+$/gu, "");
+    return (normalized || "wake").slice(0, 80);
+};

package/dist/pi/worldNudge.d.ts

@@ -0,0 +1,22 @@
+import type { WakeEvent } from "../core/types.js";
+export declare const WORLD_NUDGE_VERSION: "simfile.world-nudge.v1";
+export interface PiWorldTurnContext {
+    readonly decisionToken?: string;
+    readonly requestId: string;
+    readonly runId?: string;
+    readonly tick?: number;
+    readonly wakeId: string;
+}
+export interface PiWorldToolContextRef {
+    current?: PiWorldTurnContext;
+}
+/**
+ * Recognizes the versioned world nudge envelope and converts transport
+ * authority into a turn-local binding. The opaque token never enters the
+ * model prompt or tool schema.
+ */
+export declare const worldTurnContext: (event: WakeEvent) => PiWorldTurnContext | undefined;
+/** Creates claimable turn-local identity for every organization-owned wake. */
+export declare const worldWakeContext: (event: WakeEvent) => PiWorldTurnContext;
+export declare const formatWorldWakePrompt: (context: PiWorldTurnContext) => string;
+//# sourceMappingURL=worldNudge.d.ts.map

package/dist/pi/worldNudge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worldNudge.d.ts","sourceRoot":"","sources":["../../src/pi/worldNudge.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAElD,eAAO,MAAM,mBAAmB,EAAG,wBAAiC,CAAC;AAErE,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,qBAAqB;IACpC,OAAO,CAAC,EAAE,kBAAkB,CAAC;CAC9B;AAcD;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,GAAI,OAAO,SAAS,KAAG,kBAAkB,GAAG,SA0BxE,CAAC;AAEF,+EAA+E;AAC/E,eAAO,MAAM,gBAAgB,GAAI,OAAO,SAAS,KAAG,kBAIhD,CAAC;AAEL,eAAO,MAAM,qBAAqB,GAAI,SAAS,kBAAkB,KAAG,MASxD,CAAC"}

package/dist/pi/worldNudge.js

@@ -0,0 +1,62 @@
+import { createHash } from "node:crypto";
+export const WORLD_NUDGE_VERSION = "simfile.world-nudge.v1";
+const exactKeys = (value, expected) => {
+    const actual = Object.keys(value).sort();
+    return actual.length === expected.length
+        && actual.every((key, index) => key === [...expected].sort()[index]);
+};
+const validText = (value, maximum) => typeof value === "string"
+    && value.length > 0
+    && value.length <= maximum
+    && value === value.trim();
+/**
+ * Recognizes the versioned world nudge envelope and converts transport
+ * authority into a turn-local binding. The opaque token never enters the
+ * model prompt or tool schema.
+ */
+export const worldTurnContext = (event) => {
+    if (event.kind !== "message" || event.delivery === undefined)
+        return undefined;
+    let parsed;
+    try {
+        parsed = JSON.parse(event.transportText ?? event.text);
+    }
+    catch {
+        return undefined;
+    }
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed))
+        return undefined;
+    const record = parsed;
+    if (!exactKeys(record, ["decision_token", "run_id", "tick", "version"])
+        || record.version !== WORLD_NUDGE_VERSION
+        || !validText(record.decision_token, 512)
+        || !validText(record.run_id, 256)
+        || !Number.isSafeInteger(record.tick)
+        || record.tick < 0)
+        return undefined;
+    const requestId = `daimon-${createHash("sha256")
+        .update(`${event.id}\0${record.decision_token}`)
+        .digest("hex")}`;
+    return Object.freeze({
+        decisionToken: record.decision_token,
+        requestId,
+        runId: record.run_id,
+        tick: record.tick,
+        wakeId: event.id
+    });
+};
+/** Creates claimable turn-local identity for every organization-owned wake. */
+export const worldWakeContext = (event) => worldTurnContext(event) ?? Object.freeze({
+    requestId: `daimon-${createHash("sha256").update(event.id).digest("hex")}`,
+    wakeId: event.id,
+});
+export const formatWorldWakePrompt = (context) => [
+    context.decisionToken === undefined ? "World-capable organization wake:" : "World decision wake:",
+    ...(context.runId === undefined ? [] : [`- run_id: ${context.runId}`]),
+    ...(context.tick === undefined ? [] : [`- tick: ${context.tick}`]),
+    "",
+    context.decisionToken === undefined
+        ? "Call world_claim before using the other world tools. The harness keeps authority private."
+        : "The harness already bound this wake's authority to the world tools.",
+    "Observe current state and perform one allowed action now."
+].join("\n");

package/dist/pi/worldToolProtocol.d.ts

@@ -0,0 +1,13 @@
+import type { PiWorldTurnContext } from "./worldNudge.js";
+export declare const WORLD_ACTION_RESULT_PAGE_REQUEST_VERSION: "simfile.world-action-result-page-request.v1";
+export type PiWorldProtocolOperation = "claim" | "status" | "capabilities" | "observe" | "affordances" | "act" | "ledger";
+export interface ParsedWorldClaim {
+    readonly decisionId: string;
+    readonly decisionToken: string;
+    readonly issuedAtTick: number;
+    readonly validThroughTick: number;
+}
+export declare const createWorldClaimRequestBody: (context: PiWorldTurnContext | undefined) => Record<string, unknown> | undefined;
+export declare const createWorldRequestBody: (operation: Exclude<PiWorldProtocolOperation, "claim">, params: Record<string, unknown>, context: PiWorldTurnContext | undefined) => Record<string, unknown> | undefined;
+export declare const parseWorldClaimResponse: (value: unknown) => ParsedWorldClaim | undefined;
+//# sourceMappingURL=worldToolProtocol.d.ts.map

package/dist/pi/worldToolProtocol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worldToolProtocol.d.ts","sourceRoot":"","sources":["../../src/pi/worldToolProtocol.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAE1D,eAAO,MAAM,wCAAwC,EACnD,6CAAsD,CAAC;AAEzD,MAAM,MAAM,wBAAwB,GAChC,OAAO,GAAG,QAAQ,GAAG,cAAc,GAAG,SAAS,GAC/C,aAAa,GAAG,KAAK,GAAG,QAAQ,CAAC;AAErC,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;CACnC;AAMD,eAAO,MAAM,2BAA2B,GACtC,SAAS,kBAAkB,GAAG,SAAS,KACtC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAGhB,CAAC;AAEd,eAAO,MAAM,sBAAsB,GACjC,WAAW,OAAO,CAAC,wBAAwB,EAAE,OAAO,CAAC,EACrD,QAAQ,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,SAAS,kBAAkB,GAAG,SAAS,KACtC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAoB5B,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAAI,OAAO,OAAO,KAAG,gBAAgB,GAAG,SAe3E,CAAC"}

package/dist/pi/worldToolProtocol.js

@@ -0,0 +1,49 @@
+export const WORLD_ACTION_RESULT_PAGE_REQUEST_VERSION = "simfile.world-action-result-page-request.v1";
+const text = (value, maximum = 256) => typeof value === "string" && value.length > 0 && value.length <= maximum
+    && value === value.trim();
+export const createWorldClaimRequestBody = (context) => context !== undefined
+    && context.decisionToken === undefined && text(context.requestId) && text(context.wakeId)
+    ? { request_id: context.requestId, wake_id: context.wakeId }
+    : undefined;
+export const createWorldRequestBody = (operation, params, context) => {
+    const decisionToken = context?.decisionToken;
+    if (context === undefined || !text(decisionToken, 512) || params.decision_token !== undefined
+        || params.request_id !== undefined)
+        return undefined;
+    if (operation === "status" || operation === "capabilities" || operation === "affordances") {
+        return { decision_token: decisionToken };
+    }
+    if (operation === "observe")
+        return text(params.sense)
+            ? { decision_token: decisionToken, sense: params.sense }
+            : undefined;
+    if (operation === "act") {
+        const requestId = context.requestId;
+        if (!text(requestId) || !text(params.affordance) || !text(params.target))
+            return undefined;
+        return { decision_token: decisionToken, request_id: requestId,
+            affordance: params.affordance, target: params.target, input: params.input };
+    }
+    return { decision_token: decisionToken, version: WORLD_ACTION_RESULT_PAGE_REQUEST_VERSION,
+        ...(params.limit === undefined ? {} : { limit: params.limit }),
+        ...(params.result_after === undefined ? {} : { result_after: params.result_after }) };
+};
+export const parseWorldClaimResponse = (value) => {
+    if (value === null || typeof value !== "object" || Array.isArray(value)
+        || Object.getPrototypeOf(value) !== Object.prototype)
+        return undefined;
+    const keys = Object.keys(value).sort();
+    if (keys.length !== 4 || keys.some((key, index) => key !== [
+        "decision_id", "decision_token", "issued_at_tick", "valid_through_tick",
+    ][index]))
+        return undefined;
+    const record = value;
+    if (!text(record.decision_id) || !text(record.decision_token, 512)
+        || !Number.isSafeInteger(record.issued_at_tick) || record.issued_at_tick < 0
+        || !Number.isSafeInteger(record.valid_through_tick)
+        || record.valid_through_tick < record.issued_at_tick)
+        return undefined;
+    return Object.freeze({ decisionId: record.decision_id, decisionToken: record.decision_token,
+        issuedAtTick: record.issued_at_tick,
+        validThroughTick: record.valid_through_tick });
+};

package/dist/pi/worldTools.d.ts

@@ -0,0 +1,32 @@
+import { type ToolDefinition } from "@earendil-works/pi-coding-agent";
+import type { PiWorldToolContextRef } from "./worldNudge.js";
+export declare const PI_WORLD_TOOL_NAMES: readonly ["world_claim", "world_status", "world_capabilities", "world_observe", "world_affordances", "world_act", "world_ledger"];
+export declare const PI_WORLD_TOOL_LIMITS: Readonly<{
+    requestBytes: number;
+    responseBytes: number;
+    timeoutMs: 5000;
+}>;
+export { WORLD_ACTION_RESULT_PAGE_REQUEST_VERSION } from "./worldToolProtocol.js";
+export type PiWorldToolName = typeof PI_WORLD_TOOL_NAMES[number];
+export interface PiWorldBinding {
+    readonly url: string;
+    readonly tokenEnv: string;
+}
+export type PiWorldFetch = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+export interface CreatePiWorldToolsInput {
+    readonly world: PiWorldBinding;
+    readonly contextRef?: PiWorldToolContextRef;
+    readonly fetch?: PiWorldFetch;
+    readonly readEnvironment?: (name: string) => string | undefined;
+    readonly timeoutMs?: number;
+    readonly maxResponseBytes?: number;
+}
+export type PiWorldToolErrorCode = "world_auth_unavailable" | "world_request_cancelled" | "world_request_denied" | "world_request_invalid" | "world_request_rejected" | "world_request_timeout" | "world_response_invalid" | "world_transport_unavailable";
+export declare class PiWorldToolError extends Error {
+    readonly code: PiWorldToolErrorCode;
+    constructor(code: PiWorldToolErrorCode);
+}
+type PiWorldTool = ToolDefinition<any, unknown>;
+export declare const createPiWorldTools: (input: CreatePiWorldToolsInput) => PiWorldTool[];
+export declare const piWorldToolNames: (tools: PiWorldTool[]) => string[];
+//# sourceMappingURL=worldTools.d.ts.map

package/dist/pi/worldTools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worldTools.d.ts","sourceRoot":"","sources":["../../src/pi/worldTools.ts"],"names":[],"mappings":"AAGA,OAAO,EAAc,KAAK,cAAc,EAAE,MAAM,iCAAiC,CAAC;AAElF,OAAO,KAAK,EAAE,qBAAqB,EAAsB,MAAM,iBAAiB,CAAC;AAGjF,eAAO,MAAM,mBAAmB,mIAQrB,CAAC;AACZ,eAAO,MAAM,oBAAoB;;;;EAI/B,CAAC;AACH,OAAO,EAAE,wCAAwC,EAAE,MAAM,wBAAwB,CAAC;AAElF,MAAM,MAAM,eAAe,GAAG,OAAO,mBAAmB,CAAC,MAAM,CAAC,CAAC;AACjE,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B;AACD,MAAM,MAAM,YAAY,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,GAAG,GAAG,OAAO,EAAE,IAAI,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAC;AACpG,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,KAAK,EAAE,cAAc,CAAC;IAC/B,QAAQ,CAAC,UAAU,CAAC,EAAE,qBAAqB,CAAC;IAC5C,QAAQ,CAAC,KAAK,CAAC,EAAE,YAAY,CAAC;IAC9B,QAAQ,CAAC,eAAe,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAC;IAChE,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;CACpC;AACD,MAAM,MAAM,oBAAoB,GAC5B,wBAAwB,GACxB,yBAAyB,GACzB,sBAAsB,GACtB,uBAAuB,GACvB,wBAAwB,GACxB,uBAAuB,GACvB,wBAAwB,GACxB,6BAA6B,CAAC;AAalC,qBAAa,gBAAiB,SAAQ,KAAK;IACzC,SAAgB,IAAI,EAAE,oBAAoB,CAAC;gBAExB,IAAI,EAAE,oBAAoB;CAK9C;AAED,KAAK,WAAW,GAAG,cAAc,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;AA4JhD,eAAO,MAAM,kBAAkB,GAAI,OAAO,uBAAuB,KAAG,WAAW,EAuG9E,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAI,OAAO,WAAW,EAAE,KAAG,MAAM,EAAoC,CAAC"}