@m6d/cortex-cli 0.1.0 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@m6d/cortex-cli",
-    "version": "0.1.0",
+    "version": "0.2.0",
     "description": "Scaffold and operate Cortex servers",
     "license": "MIT",
     "type": "module",

package/src/contracts/runtime/signature.ts

@@ -90,7 +90,7 @@ type Resolve = ReturnType<typeof resolver>;
 
 function literalUnion(values: unknown[]) {
     return values
-        .filter((value) => SCALAR_TYPES.has(typeof value))
+        .filter((value) => value === null || SCALAR_TYPES.has(typeof value))
         .map((value) => JSON.stringify(value))
         .join(" | ");
 }
@@ -125,15 +125,32 @@ function inputType(schema: unknown, resolve: Resolve, depth = 0, indent = 0): st
         const rendered = variants.map((variant) => inputType(variant, resolve, depth, indent));
         return [...new Set(rendered)].join(" | ");
     }
-    if (schema.type === "null") return "null";
-    if (schema.type === "array") {
-        return `${inputType(schema.items, resolve, depth + 1, indent)}[]`;
+    const type = primaryType(schema.type);
+    const nullable = allowsNull(schema.type) ? " | null" : "";
+    if (type === "null") return "null";
+    if (type === "array") {
+        const item = inputType(schema.items, resolve, depth + 1, indent);
+        // A union item type binds looser than `[]`, so it is parenthesized.
+        return `${item.includes(" | ") ? `(${item})` : item}[]${nullable}`;
     }
-    if (schema.type === "object" || isRecord(schema.properties)) {
-        return inputObject(schema, resolve, depth, indent);
+    if (type === "object" || isRecord(schema.properties)) {
+        return inputObject(schema, resolve, depth, indent) + nullable;
     }
-    if (schema.type === "integer") return "number";
-    return SCALAR_TYPES.has(String(schema.type)) ? String(schema.type) : "unknown";
+    if (type === "integer") return `number${nullable}`;
+    return SCALAR_TYPES.has(String(type)) ? `${String(type)}${nullable}` : "unknown";
+}
+
+/** The non-null member of a JSON Schema `type`, so `["string", "null"]` reads as `string`. */
+function primaryType(type: unknown) {
+    if (!Array.isArray(type)) return type;
+    const members: unknown[] = type;
+    return members.find((member) => member !== "null");
+}
+
+function allowsNull(type: unknown) {
+    if (!Array.isArray(type)) return false;
+    const members: unknown[] = type;
+    return members.includes("null");
 }
 
 /** The branches of a union schema, under whichever keyword carries them. */
@@ -143,7 +160,9 @@ function variantsOf(schema: Record<string, unknown>) {
 }
 
 function isObjectSchema(schema: unknown): schema is Record<string, unknown> {
-    return isRecord(schema) && (schema.type === "object" || isRecord(schema.properties));
+    return (
+        isRecord(schema) && (primaryType(schema.type) === "object" || isRecord(schema.properties))
+    );
 }
 
 /**
@@ -176,7 +195,7 @@ function responseObject(schema: Record<string, unknown>, resolve: Resolve, depth
     const fields = orderedPropertyNames(schema).map((name) => {
         const child = responseUnion(properties[name], resolve);
         if (!isRecord(child) || depth >= MAX_DEPTH) return propertyName(name);
-        if (child.type === "array") {
+        if (primaryType(child.type) === "array") {
             const items = responseUnion(child.items, resolve);
             return isObjectSchema(items)
                 ? `${propertyName(name)}[].${responseObject(items, resolve, depth + 1)}`
@@ -200,7 +219,7 @@ export function responseShape(schema: unknown) {
     const resolve = resolver(schema);
     const root = responseUnion(schema, resolve);
     if (!isRecord(root)) return "{}";
-    if (root.type === "array") {
+    if (primaryType(root.type) === "array") {
         const items = responseUnion(root.items, resolve);
         return isObjectSchema(items) ? `[]${responseObject(items, resolve)}` : "[]";
     }

package/src/contracts/wire/index.ts

@@ -160,9 +160,10 @@ export type TriggerFiringSummary = {
 };
 
 /**
- * A stored message as it is persisted and served. TanStack AI's `UIMessage`
- * has no metadata field, so cortex owns the envelope: the SDK's parts plus the
- * server-derived metadata the UI renders on settled messages.
+ * A stored message as it is persisted and served: the SDK's parts plus the
+ * server-derived envelope the UIs render, carried in the SDK message's own
+ * `metadata` bag so it travels with the message over the stream and the
+ * transcript alike.
  *
  * `TPart` stays generic so this file keeps its zero dependencies — both
  * sides substitute the SDK's `MessagePart`.
@@ -175,6 +176,15 @@ export type CortexMessage<TPart = unknown> = {
     metadata?: MessageMetadata;
 };
 
+/**
+ * A stored message as the SDK's chat client takes it. The SDK has no `trigger`
+ * role, so a firing's message travels as a user turn; its true role stays on
+ * the envelope (`metadata.trigger`), which is what the UIs render the event from.
+ */
+export function toUiMessage<TPart>(message: CortexMessage<TPart>) {
+    return { ...message, role: message.role === "trigger" ? ("user" as const) : message.role };
+}
+
 /**
  * Key under the AG-UI request's `forwardedProps` carrying the answers to
  * parked client tool calls on a continuation request. The server owns the

package/src/scaffold/files.ts

@@ -27,7 +27,7 @@ export type Database = "postgres" | "mssql";
 // sync (scripts/sync-package-versions.ts) restamps it and files.test.ts holds
 // them to that.
 export const DEPENDENCIES = {
-    "@m6d/cortex-server": "~0.1.0",
+    "@m6d/cortex-server": "~0.2.0",
     "@tanstack/ai": "^0.55.0",
     "@tanstack/ai-openai": "^0.22.8",
     hono: "^4.12.3",