@ifsoul/core 0.7.0 → 0.8.0

package/README.md

@@ -15,7 +15,7 @@ compose these public artifacts. See [repository ownership](https://github.com/op
 Use Node.js 22.18–24 and an ESM project:
 
 ```sh
-npm install @ifsoul/core@0.7.0
+npm install @ifsoul/core@0.8.0
 ```
 
 The package includes compiled JavaScript and TypeScript declarations. Import the

package/dist/packages/model-providers/src/ollama.d.ts

@@ -6,4 +6,6 @@ export declare function createOllamaProvider(options?: {
     fetch?: FetchLike;
     limits?: Partial<ProviderLimits>;
     budgetPolicy?: ProviderBudgetPolicy;
+    /** Optional local sampling override within the supported product range [0, 1]. */
+    temperature?: number;
 }): OllamaClient;

package/dist/packages/model-providers/src/ollama.js

@@ -23,6 +23,10 @@ const localModel = (value) => typeof value === "string" &&
     !value.endsWith(":cloud") &&
     !/(?:^|[/:_-])(?:embed(?:ding)?s?|nomic|bge)(?:[/:_-]|$)/i.test(value);
 export function createOllamaProvider(options = {}) {
+    const { temperature } = options;
+    if (temperature !== undefined &&
+        (!Number.isFinite(temperature) || temperature < 0 || temperature > 1))
+        throw new ProviderFailure("configuration");
     const fetcher = options.fetch ?? fetch;
     const discover = async (signal, limits) => {
         const base = loopbackBase(options.baseUrl ?? DEFAULT_OLLAMA_URL);
@@ -64,6 +68,7 @@ export function createOllamaProvider(options = {}) {
                     ...(contextBudget
                         ? { num_ctx: contextBudget.windowTokens }
                         : {}),
+                    ...(temperature === undefined ? {} : { temperature }),
                 },
             }, limits);
             const raw = object(await fetchJSON(fetcher, `${base}/api/chat`, {

package/dist/packages/model-providers/src/openai.js

@@ -5,6 +5,52 @@ export const OPENAI_MODELS = [
     "gpt-4.1-mini-2025-04-14",
 ];
 export const DEFAULT_OPENAI_MODEL = OPENAI_MODELS[0];
+/** Project generation constraints into the documented Structured Outputs subset. */
+function responsesSchema(schema) {
+    const copy = structuredClone(schema);
+    function visit(value) {
+        if (!value || typeof value !== "object" || Array.isArray(value))
+            return;
+        const node = value;
+        if (typeof node.const === "string" &&
+            (node.type === undefined || node.type === "string") &&
+            (node.enum === undefined ||
+                (Array.isArray(node.enum) && node.enum.includes(node.const)))) {
+            node.type = "string";
+            node.enum = [node.const];
+            delete node.const;
+        }
+        if (node.type === "array" || node.items !== undefined)
+            delete node.uniqueItems;
+        for (const map of [
+            node.properties,
+            node.patternProperties,
+            node.$defs,
+            node.definitions,
+        ])
+            if (map && typeof map === "object" && !Array.isArray(map))
+                Object.values(map).forEach(visit);
+        for (const keyword of ["items", "prefixItems", "anyOf", "allOf", "oneOf"]) {
+            const child = node[keyword];
+            if (Array.isArray(child))
+                child.forEach(visit);
+            else
+                visit(child);
+        }
+        for (const keyword of [
+            "additionalProperties",
+            "contains",
+            "if",
+            "then",
+            "else",
+            "not",
+            "propertyNames",
+        ])
+            visit(node[keyword]);
+    }
+    visit(copy);
+    return copy;
+}
 /** Credential is confined to this client's closure and Authorization header. */
 export function createOpenAIProvider(options) {
     return {
@@ -31,7 +77,7 @@ export function createOpenAIProvider(options) {
                         type: "json_schema",
                         name: "ifsoul_content",
                         strict: true,
-                        schema: input.schema,
+                        schema: responsesSchema(input.schema),
                     },
                 },
             }, limits);

package/dist/packages/protocol/src/index.d.ts

@@ -6,6 +6,6 @@ export declare function canonical(value: unknown): string;
 export { resolveResourceLimits, BUFFERED_JSON_MAX_BYTES, MAX_TIMER_MS, } from "./resource-policy.js";
 export type { BudgetReport } from "./resource-policy.js";
 /** Current train identifier; wire families require exact kind/version validation. */
-export declare const IFSOUL_VERSION: "0.7.0";
+export declare const IFSOUL_VERSION: "0.8.0";
 /** Structural current ModelProvider spec validation; not a provider wire transport. */
 export declare function validateModelProviderDocument(value: unknown): boolean;

package/dist/packages/protocol/src/index.js

@@ -47,7 +47,7 @@ export function canonical(value) {
 }
 export { resolveResourceLimits, BUFFERED_JSON_MAX_BYTES, MAX_TIMER_MS, } from "./resource-policy.js";
 /** Current train identifier; wire families require exact kind/version validation. */
-export const IFSOUL_VERSION = "0.7.0";
+export const IFSOUL_VERSION = "0.8.0";
 /** Structural current ModelProvider spec validation; not a provider wire transport. */
 export function validateModelProviderDocument(value) {
     return validators.current_provider(value) === true;

package/dist/packages/runtime/src/behavior.d.ts

@@ -1,4 +1,4 @@
-import type { ParticipantState, ParticipantStore, SessionAccess } from "./participants.js";
+import type { AuthorizeSessionEvidence, SessionEvidenceQuery, ParticipantState, ParticipantStore, SessionAccess } from "./participants.js";
 import type { BehaviorConfiguration, BehaviorOperatorPolicy, BehaviorPermissions, BehaviorSettings, BehaviorInspection, BehaviorProposal, BehaviorEventKind, BehaviorEditorSnapshot } from "./behavior-types.js";
 export type * from "./behavior-types.js";
 export declare const DEFAULT_BEHAVIOR_OPERATOR: Readonly<BehaviorOperatorPolicy>;
@@ -20,12 +20,19 @@ export declare function effectiveBehavior(s: ParticipantState, access: SessionAc
 };
 export declare function behaviorPermissions(s: ParticipantState, access: SessionAccess, npcId: string, sessionId: string, eventId?: string, operator?: BehaviorOperatorPolicy): BehaviorPermissions;
 export declare const behaviorRevision: (s: ParticipantState) => number;
+interface EvidenceVisibilityOptions {
+    authorizeEvidence?: AuthorizeSessionEvidence;
+    purpose?: SessionEvidenceQuery["purpose"];
+    targetParticipantId?: string;
+    audienceParticipantIds?: string[];
+}
 /** Previously unobserved/unremembered evidence never becomes implicit model context. */
-export declare function behaviorEvidenceVisible(s: ParticipantState, access: SessionAccess, npcId: string, sessionId: string, eventId: string, operator?: BehaviorOperatorPolicy): boolean;
+export declare function behaviorEvidenceVisible(s: ParticipantState, access: SessionAccess, npcId: string, sessionId: string, eventId: string, operator?: BehaviorOperatorPolicy, options?: EvidenceVisibilityOptions): boolean;
 export declare function createBehaviorRuntime(store: ParticipantStore, options?: {
     operator?: BehaviorOperatorPolicy;
     limits?: Partial<BehaviorLimits>;
     ceilings?: Partial<BehaviorLimits>;
+    authorizeEvidence?: AuthorizeSessionEvidence;
 }): {
     read(a: SessionAccess): BehaviorEditorSnapshot;
     update(a: SessionAccess, expectedRevision: number, config: BehaviorConfiguration): BehaviorConfiguration;

package/dist/packages/runtime/src/behavior.js

@@ -138,21 +138,64 @@ export function behaviorPermissions(s, access, npcId, sessionId, eventId, operat
 }
 export const behaviorRevision = (s) => s.behavior?.config.revision ?? 0;
 /** Previously unobserved/unremembered evidence never becomes implicit model context. */
-export function behaviorEvidenceVisible(s, access, npcId, sessionId, eventId, operator = DEFAULT_BEHAVIOR_OPERATOR) {
-    sessionFor(s, access, sessionId, npcId);
-    const event = s.events.find((e) => e.eventId === eventId);
-    if (!event ||
-        !s.sessions.some((source) => source.sessionId === event.sessionId && source.hostId === access.hostId))
+export function behaviorEvidenceVisible(s, access, npcId, sessionId, eventId, operator = DEFAULT_BEHAVIOR_OPERATOR, options = {}) {
+    const session = sessionFor(s, access, sessionId, npcId);
+    const event = s.events.find((item) => item.eventId === eventId);
+    const sourceSession = event && s.sessions.find((item) => item.sessionId === event.sessionId);
+    if (!event || !sourceSession)
         return false;
+    const restricted = sourceSession.hostId !== access.hostId ||
+        options.authorizeEvidence !== undefined;
     if (!s.behavior)
-        return true;
-    const observation = s.behavior.observations.find((x) => x.npcId === npcId && x.eventId === eventId);
+        return !restricted;
+    const observation = s.behavior.observations.find((item) => item.npcId === npcId && item.eventId === eventId);
     const current = behaviorPermissions(s, access, npcId, sessionId, eventId, operator);
-    return (!!observation &&
-        observation.permissions.observe &&
-        observation.permissions.remember &&
-        current.observe &&
-        current.remember);
+    if (!observation?.permissions.observe ||
+        !observation.permissions.remember ||
+        !current.observe ||
+        !current.remember)
+        return false;
+    if (!restricted)
+        return true;
+    const audienceParticipantIds = [
+        ...new Set(options.audienceParticipantIds ?? []),
+    ];
+    const requiredAudience = [
+        ...new Set([
+            npcId,
+            ...audienceParticipantIds,
+            ...(options.targetParticipantId ? [options.targetParticipantId] : []),
+        ]),
+    ];
+    const recordedAudience = [
+        event.senderId,
+        ...event.recipientIds,
+        ...event.observerIds,
+    ];
+    if (!options.authorizeEvidence ||
+        !session.recallWorldIds.includes(sourceSession.worldId) ||
+        !sourceSession.members.some((member) => member.participantId === npcId && member.role === "npc") ||
+        !requiredAudience.every((id) => recordedAudience.includes(id) &&
+            sourceSession.members.some((member) => member.participantId === id)))
+        return false;
+    const sourcePermissions = behaviorPermissions(s, { ...access, hostId: sourceSession.hostId }, npcId, sourceSession.sessionId, eventId, operator);
+    if (!sourcePermissions.observe || !sourcePermissions.remember)
+        return false;
+    try {
+        return (options.authorizeEvidence(structuredClone({
+            purpose: options.purpose ?? "recall",
+            access,
+            session,
+            npcId,
+            targetParticipantId: options.targetParticipantId,
+            audienceParticipantIds,
+            sourceSession,
+            event,
+        })) === true);
+    }
+    catch {
+        return false;
+    }
 }
 function validGoals(value) {
     return (Array.isArray(value) &&
@@ -213,6 +256,7 @@ const valueKey = (value) => JSON.stringify([
     value.worldId ?? null,
 ]);
 export function createBehaviorRuntime(store, options = {}) {
+    const authorizeEvidence = options.authorizeEvidence;
     const operator = structuredClone(options.operator ?? DEFAULT_BEHAVIOR_OPERATOR);
     if (!keys(operator, [
         "canEditConfig",
@@ -250,6 +294,37 @@ export function createBehaviorRuntime(store, options = {}) {
     };
     const inspect = (s, a, sessionId, npcId) => {
         const session = sessionFor(s, a, sessionId, npcId), b = s.behavior, config = base(s);
+        const belongs = (item) => item.npcId === npcId &&
+            (!item.worldId || item.worldId === session.worldId);
+        const values = (b?.values ?? []).filter(belongs);
+        const history = (b?.history ?? []).filter(belongs);
+        const deniedKeys = new Set();
+        const acceptedKeys = new Set();
+        if (authorizeEvidence) {
+            for (const entry of history) {
+                const key = valueKey(entry);
+                if (deniedKeys.has(key) || entry.kind !== "evidence")
+                    continue;
+                const target = entry.targetParticipantId;
+                if (!entry.evidenceEventIds.length ||
+                    !entry.evidenceEventIds.every((eventId) => behaviorEvidenceVisible(s, a, npcId, sessionId, eventId, operator, {
+                        authorizeEvidence,
+                        purpose: "relationship-evidence",
+                        targetParticipantId: target,
+                        audienceParticipantIds: target ? [target] : [],
+                    }))) {
+                    deniedKeys.add(key);
+                    continue;
+                }
+                acceptedKeys.add(key);
+            }
+        }
+        const visible = (item) => {
+            if (!authorizeEvidence)
+                return true;
+            const key = valueKey(item);
+            return acceptedKeys.has(key) && !deniedKeys.has(key);
+        };
         return {
             npcId,
             sessionId,
@@ -257,8 +332,8 @@ export function createBehaviorRuntime(store, options = {}) {
             stateRevision: b ? revision(b, npcId) : 0,
             effective: effectiveBehavior(s, a, npcId, sessionId, operator),
             parameters: config.parameters,
-            values: (b?.values ?? []).filter((v) => v.npcId === npcId && (!v.worldId || v.worldId === session.worldId)),
-            history: (b?.history ?? []).filter((v) => v.npcId === npcId && (!v.worldId || v.worldId === session.worldId)),
+            values: values.filter(visible),
+            history: history.filter(visible),
         };
     };
     return {
@@ -501,13 +576,26 @@ export function createBehaviorRuntime(store, options = {}) {
                         const e = s.events.find((e) => e.eventId === eventId), sourceSession = e && s.sessions.find((x) => x.sessionId === e.sessionId), observed = b.observations.find((o) => o.eventId === eventId && o.npcId === proposal.npcId);
                         if (!e ||
                             !sourceSession ||
-                            sourceSession.hostId !== a.hostId ||
                             !session.recallWorldIds.includes(sourceSession.worldId) ||
                             (d.scope === "world" &&
                                 sourceSession.worldId !== session.worldId) ||
                             !observed?.permissions.observe ||
                             ![e.senderId, ...e.recipientIds, ...e.observerIds].includes(proposal.npcId))
                             return failure("unauthorized");
+                        const external = sourceSession.hostId !== a.hostId;
+                        if (external || authorizeEvidence) {
+                            const target = change.targetParticipantId;
+                            if ((external && d.kind !== "relationship") ||
+                                !behaviorEvidenceVisible(s, a, proposal.npcId, proposal.sessionId, eventId, operator, {
+                                    authorizeEvidence,
+                                    purpose: "relationship-evidence",
+                                    targetParticipantId: target,
+                                    audienceParticipantIds: target ? [target] : [],
+                                }) ||
+                                (d.kind === "relationship" &&
+                                    !behaviorPermissions(s, { ...a, hostId: sourceSession.hostId }, proposal.npcId, sourceSession.sessionId, eventId, operator).updateRelationship))
+                                return failure("unauthorized");
+                        }
                         const current = behaviorPermissions(s, a, proposal.npcId, proposal.sessionId, eventId, operator);
                         if (!current.observe ||
                             (d.kind === "relationship" &&
@@ -528,9 +616,11 @@ export function createBehaviorRuntime(store, options = {}) {
                             : {}),
                         ...(d.scope === "world" ? { worldId: session.worldId } : {}),
                     }, key = valueKey(keyData);
+                    const priorEvidence = new Set(b.history
+                        .filter((entry) => valueKey(entry) === key)
+                        .flatMap((entry) => entry.evidenceEventIds));
                     if (changedKeys.has(key) ||
-                        b.history.some((h) => valueKey(h) === key &&
-                            h.evidenceEventIds.some((e) => change.evidenceEventIds.includes(e))))
+                        change.evidenceEventIds.every((eventId) => priorEvidence.has(eventId)))
                         return failure("conflict");
                     changedKeys.add(key);
                     const initialValues = effectiveBehavior(s, a, proposal.npcId, proposal.sessionId, operator).initialValues;

package/dist/packages/runtime/src/participants.d.ts

@@ -43,6 +43,18 @@ export interface AddressedEvent {
     observerIds: string[];
     text: string;
 }
+/** Server-supplied authority over one existing event from a different host. */
+export interface SessionEvidenceQuery {
+    purpose: "recall" | "relationship-evidence";
+    access: SessionAccess;
+    session: ParticipantSession;
+    npcId: string;
+    targetParticipantId?: string;
+    audienceParticipantIds: string[];
+    sourceSession: ParticipantSession;
+    event: AddressedEvent;
+}
+export type AuthorizeSessionEvidence = (query: Readonly<SessionEvidenceQuery>) => boolean;
 export interface SessionTurn {
     turnId: string;
     sessionId: string;
@@ -82,6 +94,7 @@ export declare class SessionError extends Error {
 /** No account system, model, transport or host mechanics are constructed here. */
 export declare function createParticipantRuntime(store: ParticipantStore, options?: {
     behaviorOperator?: BehaviorOperatorPolicy;
+    authorizeEvidence?: AuthorizeSessionEvidence;
 }): {
     /** Only trusted verified host mappings may call this; imported IDs never register themselves. */
     register(access: SessionAccess, participant: SessionParticipant): SessionParticipant;

package/dist/packages/runtime/src/participants.js

@@ -30,6 +30,7 @@ const audience = (e) => [
 ];
 /** No account system, model, transport or host mechanics are constructed here. */
 export function createParticipantRuntime(store, options = {}) {
+    const authorizeEvidence = options.authorizeEvidence;
     const behaviorOperator = options.behaviorOperator
         ? structuredClone(options.behaviorOperator)
         : undefined;
@@ -166,13 +167,33 @@ export function createParticipantRuntime(store, options = {}) {
         history(access, sessionId, participantId) {
             return run(access, (s) => {
                 const current = session(s, access, sessionId);
-                if (!current.members.some((m) => m.participantId === participantId))
-                    fail("unauthorized");
-                return s.events.filter((e) => e.sessionId === sessionId &&
-                    audience(e).includes(participantId) &&
-                    (current.members.find((m) => m.participantId === participantId)
-                        ?.role !== "npc" ||
-                        behaviorEvidenceVisible(s, access, participantId, sessionId, e.eventId)));
+                const member = current.members.find((item) => item.participantId === participantId);
+                if (!member)
+                    return fail("unauthorized");
+                return s.events.filter((event) => {
+                    const recordedAudience = audience(event);
+                    if (event.sessionId !== sessionId ||
+                        !recordedAudience.includes(participantId))
+                        return false;
+                    if (!authorizeEvidence)
+                        return (member.role !== "npc" ||
+                            behaviorEvidenceVisible(s, access, participantId, sessionId, event.eventId));
+                    const npcs = current.members.filter((item) => item.role === "npc" &&
+                        recordedAudience.includes(item.participantId) &&
+                        (member.role === "player" ||
+                            item.participantId === participantId));
+                    const players = current.members.filter((item) => item.role === "player" &&
+                        recordedAudience.includes(item.participantId));
+                    return npcs.some((npc) => behaviorEvidenceVisible(s, access, npc.participantId, sessionId, event.eventId, behaviorOperator, {
+                        authorizeEvidence,
+                        audienceParticipantIds: recordedAudience.filter((id) => id !== npc.participantId),
+                        targetParticipantId: member.role === "player"
+                            ? participantId
+                            : players.length === 1
+                                ? players[0]?.participantId
+                                : undefined,
+                    }));
+                });
             });
         },
         /** Source-grounded relationship evidence, keyed by verified persistent player ID. */
@@ -185,11 +206,20 @@ export function createParticipantRuntime(store, options = {}) {
                 return {
                     npcId,
                     playerId,
-                    events: s.events.filter((e) => audience(e).includes(npcId) &&
-                        audience(e).includes(playerId) &&
-                        s.sessions.some((source) => source.sessionId === e.sessionId &&
-                            source.hostId === access.hostId &&
-                            current.recallWorldIds.includes(source.worldId))),
+                    events: s.events.filter((event) => {
+                        if (![npcId, playerId].every((id) => audience(event).includes(id)))
+                            return false;
+                        const source = s.sessions.find((item) => item.sessionId === event.sessionId);
+                        return (!!source &&
+                            current.recallWorldIds.includes(source.worldId) &&
+                            ((source.hostId === access.hostId && !authorizeEvidence) ||
+                                behaviorEvidenceVisible(s, access, npcId, sessionId, event.eventId, behaviorOperator, {
+                                    authorizeEvidence,
+                                    purpose: "relationship-evidence",
+                                    targetParticipantId: playerId,
+                                    audienceParticipantIds: [playerId],
+                                })));
+                    }),
                 };
             });
         },
@@ -243,16 +273,20 @@ export function createParticipantRuntime(store, options = {}) {
                     behaviorRevision: behaviorRevision(s),
                 });
                 // Recall is NPC-private, with stable player identity across worlds. Sharing is checked at completion.
+                const participants = [...ticket.recipientIds, ...ticket.observerIds];
+                const playerIds = participants.filter((id) => current.members.some((member) => member.role === "player" && member.participantId === id));
                 const memories = s.events
-                    .filter((e) => s.sessions.some((source) => source.sessionId === e.sessionId &&
-                    source.hostId === access.hostId &&
-                    current.recallWorldIds.includes(source.worldId)) &&
-                    behaviorEvidenceVisible(s, access, ticket.npcId, ticket.sessionId, e.eventId) &&
-                    [
-                        ticket.npcId,
-                        ...ticket.recipientIds,
-                        ...ticket.observerIds,
-                    ].every((p) => audience(e).includes(p)))
+                    .filter((event) => {
+                    const source = s.sessions.find((item) => item.sessionId === event.sessionId);
+                    return (!!source &&
+                        current.recallWorldIds.includes(source.worldId) &&
+                        [ticket.npcId, ...participants].every((id) => audience(event).includes(id)) &&
+                        behaviorEvidenceVisible(s, access, ticket.npcId, ticket.sessionId, event.eventId, source.hostId === access.hostId ? undefined : behaviorOperator, {
+                            authorizeEvidence,
+                            targetParticipantId: playerIds.length === 1 ? playerIds[0] : undefined,
+                            audienceParticipantIds: participants,
+                        }));
+                })
                     .slice(-64);
                 if (new TextEncoder().encode(JSON.stringify({ ticket, trigger, memories })).length > 65536)
                     return fail("limit");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ifsoul/core",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "private": false,
   "type": "module",
   "description": "Experimental public IfSoul protocol, runtime, memory and provider primitives",

package/release.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.7.0",
+  "version": "0.8.0",
   "current": {
     "protocol": "0.4.0",
     "modelProvider": "0.4.0",