ai-workflow-logic 0.1.1 → 0.1.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-workflow-logic",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "private": false,
   "description": "AI workflow domain projections and pure runtime helpers with an explicit Halfcode filesystem adapter",
   "type": "module",
@@ -12,14 +12,13 @@
     "./run-freeze": "./src/run-freeze.ts"
   },
   "dependencies": {
-    "ai-workflow-contract": "workspace:*",
+    "ai-workflow-contract": "0.1.3",
     "halfcode-compiler.xnl": "0.2.2"
   },
   "files": [
     "src"
   ],
   "publishConfig": {
-    "access": "public",
-    "registry": "https://registry.npmjs.com"
+    "access": "public"
   }
 }

package/src/agent-resources.ts

@@ -2,10 +2,13 @@ import type {
   AIAgentDefinitionProjection,
   AIAgentMessageProjection,
   AIAgentMessageRole,
+  AIWorkflowEffectPolicyProjection,
   AIWorkflowAgentResourceProjection,
   AIWorkflowAgentResourceRelation,
   AIWorkflowAgentTaskRef,
   AIWorkflowDefinitionResourceKind,
+  AIWorkflowMaterialValueProjection,
+  AIWorkflowMessageSchemaProjection,
   AIWorkflowResourceProjectionDiagnostic,
   AIWorkflowResourceRegistryView,
   AIWorkflowTypedResourceRef,
@@ -114,7 +117,7 @@ function projectMaterialPort(
     diagnostics.push(diagnostic('AI_MATERIAL_PORT_CARDINALITY_INVALID', resource.documentUri, 'MaterialPort cardinality must be one or many.'));
     valid = false;
   }
-  const schema = projectOptionalTypedSubdomain(
+  const schema = projectOptionalSchemaSubdomain(
     resource,
     'SchemaRef',
     resources,
@@ -147,12 +150,12 @@ function projectAgentDefinition(
   const messages = messagesNode
     ? projectMessages(resource, messagesNode, resources, edges, diagnostics)
     : [];
-  const inputSchema = projectOptionalTypedSubdomain(resource, 'InputSchemaRef', resources, 'agent-input-schema', edges, diagnostics);
-  const outputSchema = projectOptionalTypedSubdomain(resource, 'OutputSchemaRef', resources, 'agent-output-schema', edges, diagnostics);
+  const inputSchema = projectOptionalSchemaSubdomain(resource, 'InputSchemaRef', resources, 'agent-input-schema', edges, diagnostics);
+  const outputSchema = projectOptionalSchemaSubdomain(resource, 'OutputSchemaRef', resources, 'agent-output-schema', edges, diagnostics);
   const tools = toolRefsNode
     ? projectTypedRefList(resource, toolRefsNode, 'ToolRef', resources, 'agent-tool', edges, diagnostics)
     : [];
-  const effectPolicy = projectOptionalTypedSubdomain(resource, 'EffectPolicyRef', resources, 'agent-effect-policy', edges, diagnostics);
+  const effectPolicy = projectOptionalEffectPolicySubdomain(resource, 'EffectPolicyRef', resources, 'agent-effect-policy', edges, diagnostics);
   const materialPorts = materialPortRefsNode
     ? projectTypedRefList(resource, materialPortRefsNode, 'MaterialPortRef', resources, 'agent-material-port', edges, diagnostics, 'MaterialPort')
     : [];
@@ -209,7 +212,7 @@ function projectMessages(
     if (prompt) edges.push(edge(resource.resourceId, prompt.resource.resourceId, 'agent-message-prompt'));
     const schemaNode = value.subdomains.SchemaRef;
     const schema = schemaNode?.tag === 'SchemaRef'
-      ? projectTypedRefNode(schemaNode, resources, `${location}#SchemaRef`, diagnostics)
+      ? projectMessageSchemaRefNode(schemaNode, resources, `${location}#SchemaRef`, diagnostics)
       : undefined;
     if (schemaNode && schemaNode.tag !== 'SchemaRef') diagnostics.push(diagnostic('AI_RESOURCE_SUBDOMAIN_TAG_MISMATCH', `${location}#SchemaRef`, `Subdomain SchemaRef must contain a SchemaRef node, got '${schemaNode.tag}'.`));
     if (schema) edges.push(edge(resource.resourceId, schema.resource.resourceId, 'agent-message-schema'));
@@ -274,6 +277,69 @@ function projectOptionalTypedSubdomain(
   return typedRef;
 }
 
+function projectOptionalSchemaSubdomain(
+  owner: ResourceRecord,
+  name: string,
+  resources: ReadonlyMap<string, ResourceRecord>,
+  relation: AIWorkflowAgentResourceRelation,
+  edges: ResourceDependencyEdge[],
+  diagnostics: AIWorkflowResourceProjectionDiagnostic[],
+): AIWorkflowMessageSchemaProjection | undefined {
+  const node = owner.node.subdomains[name];
+  if (!node) return undefined;
+  if (node.tag !== name) {
+    diagnostics.push(diagnostic('AI_RESOURCE_SUBDOMAIN_TAG_MISMATCH', `${owner.documentUri}#${name}`, `Subdomain ${name} must contain a ${name} node, got '${node.tag}'.`));
+    return undefined;
+  }
+  const schema = projectMessageSchemaRefNode(node, resources, `${owner.documentUri}#${name}`, diagnostics);
+  if (schema) edges.push(edge(owner.resourceId, schema.resource.resourceId, relation));
+  return schema;
+}
+
+function projectOptionalEffectPolicySubdomain(
+  owner: ResourceRecord,
+  name: string,
+  resources: ReadonlyMap<string, ResourceRecord>,
+  relation: AIWorkflowAgentResourceRelation,
+  edges: ResourceDependencyEdge[],
+  diagnostics: AIWorkflowResourceProjectionDiagnostic[],
+): AIWorkflowEffectPolicyProjection | undefined {
+  const node = owner.node.subdomains[name];
+  if (!node) return undefined;
+  if (node.tag !== name) {
+    diagnostics.push(diagnostic('AI_RESOURCE_SUBDOMAIN_TAG_MISMATCH', `${owner.documentUri}#${name}`, `Subdomain ${name} must contain a ${name} node, got '${node.tag}'.`));
+    return undefined;
+  }
+  const typedRef = projectTypedRefNode(node, resources, `${owner.documentUri}#${name}`, diagnostics, 'EffectPolicy');
+  if (!typedRef) return undefined;
+  const supportedProperties = new Set(['lifecycle', 'description', 'toolMode']);
+  const unsupportedProperties = Reflect.ownKeys(typedRef.resource.node.properties)
+    .filter((key) => typeof key !== 'string' || !supportedProperties.has(key))
+    .map((key) => typeof key === 'string' ? key : key.toString())
+    .sort(compareCodeUnits);
+  if (unsupportedProperties.length > 0) {
+    for (const property of unsupportedProperties) {
+      diagnostics.push(diagnostic(
+        'AI_EFFECT_POLICY_PROPERTY_UNSUPPORTED',
+        `${typedRef.resource.documentUri}#${property}`,
+        `EffectPolicy property '${property}' is not part of the closed executable policy contract.`,
+      ));
+    }
+    return undefined;
+  }
+  const toolMode = ownResourceValue(typedRef.resource.node.properties, 'toolMode');
+  if (toolMode !== 'declared-only' && toolMode !== 'none') {
+    diagnostics.push(diagnostic(
+      'AI_EFFECT_POLICY_TOOL_MODE_INVALID',
+      typedRef.resource.documentUri,
+      "EffectPolicy toolMode must be 'declared-only' or 'none'.",
+    ));
+    return undefined;
+  }
+  edges.push(edge(owner.resourceId, typedRef.resource.resourceId, relation));
+  return Object.freeze({ ...typedRef, kind: 'EffectPolicy', toolMode });
+}
+
 function projectMaterialBinding(
   resource: ResourceRecord,
   resources: ReadonlyMap<string, ResourceRecord>,
@@ -287,7 +353,10 @@ function projectMaterialBinding(
   const materialNode = requiredSubdomain(resource, 'MaterialRef', diagnostics);
   const task = taskNode ? projectTaskRef(taskNode, resources, `${resource.documentUri}#AgentTaskRef`, diagnostics) : undefined;
   const portRef = portNode ? projectTypedRefNode(portNode, resources, `${resource.documentUri}#PortRef`, diagnostics, 'MaterialPort') : undefined;
-  const material = materialNode ? projectTypedRefNode(materialNode, resources, `${resource.documentUri}#MaterialRef`, diagnostics) : undefined;
+  const materialRef = materialNode ? projectTypedRefNode(materialNode, resources, `${resource.documentUri}#MaterialRef`, diagnostics) : undefined;
+  const material = materialRef
+    ? projectMaterialValue(materialRef, diagnostics)
+    : undefined;
   if (portRef) edges.push(edge(resource.resourceId, portRef.resource.resourceId, 'material-binding-port'));
   if (material) edges.push(edge(resource.resourceId, material.resource.resourceId, 'material-binding-material'));
   const port = portRef ? portsById.get(portRef.resource.resourceId) : undefined;
@@ -303,6 +372,134 @@ function projectMaterialBinding(
   });
 }
 
+function projectMessageSchemaRefNode(
+  node: ResourceNode,
+  resources: ReadonlyMap<string, ResourceRecord>,
+  location: string,
+  diagnostics: AIWorkflowResourceProjectionDiagnostic[],
+): AIWorkflowMessageSchemaProjection | undefined {
+  const typedRef = projectTypedRefNode(node, resources, location, diagnostics, 'MessageSchema');
+  if (!typedRef) return undefined;
+  const schemaValue = ownResourceValue(typedRef.resource.node.properties, 'schema');
+  if (!isResourceValueMap(schemaValue)) {
+    diagnostics.push(diagnostic(
+      'AI_MESSAGE_SCHEMA_VALUE_INVALID',
+      typedRef.resource.documentUri,
+      'MessageSchema must declare one explicit schema map.',
+    ));
+    return undefined;
+  }
+  const schema = cloneResourceValue(schemaValue, typedRef.resource.documentUri, diagnostics, 'AI_MESSAGE_SCHEMA_VALUE_INVALID');
+  if (!isResourceValueMap(schema)) return undefined;
+  return Object.freeze({ ...typedRef, kind: 'MessageSchema', schema });
+}
+
+function projectMaterialValue(
+  typedRef: AIWorkflowTypedResourceRef,
+  diagnostics: AIWorkflowResourceProjectionDiagnostic[],
+): AIWorkflowMaterialValueProjection | undefined {
+  const value = ownResourceValue(typedRef.resource.node.properties, 'value');
+  if (value === undefined) {
+    diagnostics.push(diagnostic(
+      'AI_MATERIAL_VALUE_MISSING',
+      typedRef.resource.documentUri,
+      `Material '${typedRef.resource.resourceId}' must declare one explicit value.`,
+    ));
+    return undefined;
+  }
+  const cloned = cloneResourceValue(value, typedRef.resource.documentUri, diagnostics, 'AI_MATERIAL_VALUE_INVALID');
+  return cloned === undefined ? undefined : Object.freeze({ ...typedRef, value: cloned });
+}
+
+function ownResourceValue(
+  record: Readonly<Record<string, ResourceValue>>,
+  field: string,
+): ResourceValue | undefined {
+  const descriptor = Object.getOwnPropertyDescriptor(record, field);
+  return descriptor && descriptor.enumerable && 'value' in descriptor
+    ? descriptor.value
+    : undefined;
+}
+
+function isResourceValueMap(value: ResourceValue | undefined): value is Readonly<Record<string, ResourceValue>> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value) && !isResourceNode(value);
+}
+
+function cloneResourceValue(
+  value: ResourceValue,
+  location: string,
+  diagnostics: AIWorkflowResourceProjectionDiagnostic[],
+  code: string,
+  ancestors: WeakSet<object> = new WeakSet(),
+): ResourceValue | undefined {
+  if (value === null || typeof value === 'string' || typeof value === 'boolean') return value;
+  if (typeof value === 'number') {
+    if (Number.isFinite(value)) return value;
+    diagnostics.push(diagnostic(code, location, 'Executable resource values may contain only finite numbers.'));
+    return undefined;
+  }
+  if (ancestors.has(value)) {
+    diagnostics.push(diagnostic(code, location, 'Executable resource values must not contain cycles.'));
+    return undefined;
+  }
+  ancestors.add(value);
+  if (Array.isArray(value)) {
+    const keys = Reflect.ownKeys(value);
+    const expected = new Set([...value.keys()].map(String).concat('length'));
+    if (keys.some((key) => typeof key !== 'string' || !expected.has(key))) {
+      diagnostics.push(diagnostic(code, location, 'Executable resource arrays must be dense plain-data arrays.'));
+      ancestors.delete(value);
+      return undefined;
+    }
+    const output: ResourceValue[] = [];
+    for (let index = 0; index < value.length; index += 1) {
+      const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+      if (!descriptor || !descriptor.enumerable || !('value' in descriptor)) {
+        diagnostics.push(diagnostic(code, location, 'Executable resource arrays must be dense plain-data arrays.'));
+        ancestors.delete(value);
+        return undefined;
+      }
+      const item = cloneResourceValue(descriptor.value as ResourceValue, location, diagnostics, code, ancestors);
+      if (item === undefined) {
+        ancestors.delete(value);
+        return undefined;
+      }
+      output.push(item);
+    }
+    ancestors.delete(value);
+    return Object.freeze(output);
+  }
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null) {
+    diagnostics.push(diagnostic(code, location, 'Executable resource maps must be plain-data objects.'));
+    ancestors.delete(value);
+    return undefined;
+  }
+  const output: Record<string, ResourceValue> = Object.create(null) as Record<string, ResourceValue>;
+  const keys = Reflect.ownKeys(value);
+  if (keys.some((key) => typeof key !== 'string')) {
+    diagnostics.push(diagnostic(code, location, 'Executable resource maps may contain only string keys.'));
+    ancestors.delete(value);
+    return undefined;
+  }
+  for (const key of (keys as string[]).sort(compareCodeUnits)) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (!descriptor || !descriptor.enumerable || !('value' in descriptor)) {
+      diagnostics.push(diagnostic(code, location, 'Executable resource maps must contain only enumerable data properties.'));
+      ancestors.delete(value);
+      return undefined;
+    }
+    const item = cloneResourceValue(descriptor.value as ResourceValue, location, diagnostics, code, ancestors);
+    if (item === undefined) {
+      ancestors.delete(value);
+      return undefined;
+    }
+    output[key] = item;
+  }
+  ancestors.delete(value);
+  return Object.freeze(output);
+}
+
 function projectTaskRef(
   node: ResourceNode,
   resources: ReadonlyMap<string, ResourceRecord>,

package/src/run-freeze.ts

@@ -154,18 +154,38 @@ function semanticResourceFingerprint(
         id: message.id,
         role: message.role,
         prompt: [message.prompt.kind, message.prompt.resource.resourceId],
-        schema: message.schema ? [message.schema.kind, message.schema.resource.resourceId] : null,
+        schema: message.schema ? {
+          kind: message.schema.kind,
+          resourceId: message.schema.resource.resourceId,
+          value: message.schema.schema,
+        } : null,
       })),
-      inputSchema: agent.inputSchema ? [agent.inputSchema.kind, agent.inputSchema.resource.resourceId] : null,
-      outputSchema: agent.outputSchema ? [agent.outputSchema.kind, agent.outputSchema.resource.resourceId] : null,
+      inputSchema: agent.inputSchema ? {
+        kind: agent.inputSchema.kind,
+        resourceId: agent.inputSchema.resource.resourceId,
+        value: agent.inputSchema.schema,
+      } : null,
+      outputSchema: agent.outputSchema ? {
+        kind: agent.outputSchema.kind,
+        resourceId: agent.outputSchema.resource.resourceId,
+        value: agent.outputSchema.schema,
+      } : null,
       tools: agent.tools.map((ref) => [ref.kind, ref.resource.resourceId]),
-      effectPolicy: agent.effectPolicy ? [agent.effectPolicy.kind, agent.effectPolicy.resource.resourceId] : null,
+      effectPolicy: agent.effectPolicy ? {
+        kind: agent.effectPolicy.kind,
+        resourceId: agent.effectPolicy.resource.resourceId,
+        toolMode: agent.effectPolicy.toolMode,
+      } : null,
       materialPorts: agent.materialPorts.map((ref) => [ref.kind, ref.resource.resourceId]),
     },
     bindings: bindings.map((binding) => ({
       resourceId: binding.resource.resourceId,
       port: [binding.port.resource.resourceId, binding.port.materialKind, binding.port.required, binding.port.cardinality],
-      material: [binding.material.kind, binding.material.resource.resourceId],
+      material: {
+        kind: binding.material.kind,
+        resourceId: binding.material.resource.resourceId,
+        value: binding.material.value,
+      },
     })),
     closure: closure.map((resource) => ({
       resourceId: resource.resourceId,