@undefineds.co/models 0.2.26 → 0.2.28

package/README.md

@@ -31,6 +31,18 @@ import {
 } from '@undefineds.co/models'
 ```
 
+## Pi Package
+
+`@undefineds.co/models` is also a Pi package. It exposes the shared
+`solid-modeling` skill through the package manifest, so Pi users can install it
+from npm or git:
+
+```bash
+pi install npm:@undefineds.co/models
+```
+
+After installation, Pi can load the skill from `skills/solid-modeling/SKILL.md`.
+
 ## Namespaces
 
 LinX-owned predicates and classes use the company namespace:

package/dist/approval.schema.js

@@ -2,6 +2,7 @@ import { extractPodResourceTemplateValue, podTable, uri, string, text, timestamp
 import { ODRL, UDFS, DCTerms } from './namespaces.js';
 import { chatResource } from './chat.schema.js';
 import { threadResource } from './thread.schema.js';
+import { asPodResourceTemplateTarget } from './repository.js';
 export function buildApprovalSubjectPath(approvalId, createdAt = new Date()) {
     const date = createdAt instanceof Date ? createdAt : new Date(createdAt);
     const safeDate = Number.isFinite(date.getTime()) ? date : new Date();
@@ -14,7 +15,7 @@ export function extractApprovalIdFromApprovalRef(approvalRef) {
     if (approvalRef && !/[/:#]/.test(approvalRef)) {
         return approvalRef;
     }
-    return extractPodResourceTemplateValue(approvalResource, approvalRef);
+    return extractPodResourceTemplateValue(asPodResourceTemplateTarget(approvalResource), approvalRef);
 }
 // Approval request resource (separate from Solid inbox notifications).
 export const approvalResource = podTable('approval', {

package/dist/audit.schema.js

@@ -2,6 +2,7 @@ import { extractPodResourceTemplateValue, podTable, uri, string, timestamp, id }
 import { UDFS, DCTerms } from './namespaces.js';
 import { chatResource } from './chat.schema.js';
 import { threadResource } from './thread.schema.js';
+import { asPodResourceTemplateTarget } from './repository.js';
 export function buildAuditSubjectPath(auditId, createdAt = new Date()) {
     const date = createdAt instanceof Date ? createdAt : new Date(createdAt);
     const safeDate = Number.isFinite(date.getTime()) ? date : new Date();
@@ -45,7 +46,7 @@ export function extractAuditIdFromAuditRef(auditRef) {
     if (auditRef && !/[/:#]/.test(auditRef)) {
         return auditRef;
     }
-    return extractPodResourceTemplateValue(auditResource, auditRef);
+    return extractPodResourceTemplateValue(asPodResourceTemplateTarget(auditResource), auditRef);
 }
 // Compatibility alias. New model code should prefer `auditResource`.
 export const auditTable = auditResource;

package/dist/bin/udfs.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin/udfs.js

@@ -0,0 +1,430 @@
+#!/usr/bin/env node
+import { createPodStorage, podSchema, XPOD_CREDENTIAL, } from '../index.js';
+async function main(argv) {
+    const [area, action, ...rest] = argv;
+    if (!area || area === 'help' || area === '--help' || area === '-h') {
+        printHelp();
+        return;
+    }
+    if (area === 'schema') {
+        handleSchema(action, rest);
+        return;
+    }
+    if (area === 'storage') {
+        handleStorage(action, rest);
+        return;
+    }
+    if (area === 'consensus') {
+        await handleConsensus(action, rest);
+        return;
+    }
+    throw new Error(`Unknown udfs command: ${area}`);
+}
+function handleSchema(action, args) {
+    if (action === 'list') {
+        writeJson(podSchema.list());
+        return;
+    }
+    if (action === 'describe') {
+        const uri = args[0];
+        if (!uri)
+            throw new Error('Usage: udfs schema describe <uri>');
+        const descriptor = podSchema.describe({ uri });
+        if (!descriptor)
+            throw new Error(`Descriptor not found: ${uri}`);
+        writeJson(descriptor);
+        return;
+    }
+    if (action === 'classes') {
+        writeJson(podSchema.classes({
+            uri: readOption(args, '--uri'),
+        }));
+        return;
+    }
+    if (action === 'search') {
+        const query = readOption(args, '--query') ?? args[0];
+        if (!query)
+            throw new Error('Usage: udfs schema search --query <text>');
+        writeJson(podSchema.search({
+            query,
+            source: readOption(args, '--source'),
+            resourceKind: readOption(args, '--resource-kind'),
+            limit: readNumberOption(args, '--limit'),
+        }));
+        return;
+    }
+    if (action === 'predicates') {
+        writeJson(podSchema.predicates({
+            uri: readOption(args, '--uri'),
+            field: readOption(args, '--field'),
+        }));
+        return;
+    }
+    throw new Error(`Unknown schema command: ${action ?? '(missing)'}`);
+}
+function handleStorage(action, args) {
+    if (action === 'validate') {
+        const input = readInputPayload(args, 'udfs storage validate --input \'<mutation-json>\'');
+        writeJson(createPodStorage().validate(input));
+        return;
+    }
+    throw new Error(`Unknown storage command: ${action ?? '(missing)'}`);
+}
+async function handleConsensus(action, args) {
+    if (!action || action === '--help' || action === '-h') {
+        printConsensusHelp();
+        return;
+    }
+    const allArgs = [action, ...args];
+    const input = readConsensusInput(allArgs);
+    const result = await resolveConsensusRequest({
+        sessionId: input.session_id,
+        request: input.request,
+        tokenType: input.answers?.token_type ?? 'tunnel-token',
+        conversation: input.conversation_id ?? process.env.UDFS_CONSENSUS_CONVERSATION_ID,
+    });
+    if (allArgs.includes('--json')) {
+        writeJson(result);
+        return;
+    }
+    process.stdout.write(`Consensus: ${input.request}\n`);
+    if (result.session_id) {
+        process.stdout.write(`Session: ${result.session_id}\n`);
+    }
+    process.stdout.write(`Consensus runtime: ${result.consensusRuntime.mode}${result.consensusRuntime.mode === 'remote' ? ` (${result.consensusRuntime.baseUrl})` : ''}\n`);
+    if (result.consensusResponse?.conversationId) {
+        process.stdout.write(`Conversation: ${result.consensusResponse.conversationId}\n`);
+    }
+    process.stdout.write(`Clarification: ${result.first.questions[0].question}\n`);
+    process.stdout.write(`Answer: ${input.answers?.token_type ?? 'tunnel-token'}\n`);
+    process.stdout.write(`Schema: ${result.resolved.schemaUri}\n`);
+    process.stdout.write(`Descriptor storage: ${result.descriptor.storage.base}${result.descriptor.storage.resourceIdPattern}\n`);
+}
+function resolveConsensusRuntime() {
+    const baseUrl = process.env.UDFS_CONSENSUS_BASE_URL;
+    const token = process.env.UDFS_CONSENSUS_TOKEN;
+    if (baseUrl && token) {
+        return {
+            mode: 'remote',
+            baseUrl,
+            auth: 'runtime-token',
+        };
+    }
+    return {
+        mode: 'local-fallback',
+        auth: 'none',
+    };
+}
+async function resolveConsensusRequest(input) {
+    const runtime = resolveConsensusRuntime();
+    if (runtime.mode === 'remote') {
+        const remote = await callRemoteConsensus({
+            runtime,
+            sessionId: input.sessionId,
+            request: input.request,
+            conversation: input.conversation,
+        });
+        const parsed = parseRemoteConsensusPayload(remote.body);
+        const resolved = coerceResolvedConsensusPayload(parsed);
+        if (!resolved) {
+            throw new Error('Remote Consensus response did not contain a resolved schema payload');
+        }
+        return buildConsensusResult({
+            runtime,
+            sessionId: input.sessionId,
+            tokenType: input.tokenType,
+            fieldMapping: resolved.fieldMapping,
+            confidence: resolved.confidence,
+            response: {
+                id: remote.id,
+                conversationId: remote.conversationId,
+                parsed,
+            },
+        });
+    }
+    return buildConsensusResult({
+        runtime,
+        sessionId: input.sessionId,
+        tokenType: input.tokenType,
+    });
+}
+async function callRemoteConsensus(input) {
+    const token = process.env.UDFS_CONSENSUS_TOKEN;
+    if (!token) {
+        throw new Error('Remote Consensus requires injected UDFS_CONSENSUS_TOKEN');
+    }
+    const body = {
+        model: process.env.UDFS_CONSENSUS_MODEL ?? 'consensus-modeling',
+        input: [
+            {
+                role: 'user',
+                content: [
+                    {
+                        type: 'input_text',
+                        text: input.request,
+                    },
+                ],
+            },
+        ],
+        metadata: {
+            product: 'linx',
+            purpose: 'pod-storage',
+            ...(input.sessionId ? { session_id: input.sessionId } : {}),
+        },
+    };
+    if (input.conversation) {
+        body.conversation = input.conversation;
+    }
+    const response = await fetch(`${input.runtime.baseUrl.replace(/\/+$/u, '')}/responses`, {
+        method: 'POST',
+        headers: {
+            authorization: `Bearer ${token}`,
+            'content-type': 'application/json',
+        },
+        body: JSON.stringify(body),
+    });
+    const text = await response.text();
+    const parsedBody = text ? JSON.parse(text) : {};
+    if (!response.ok) {
+        throw new Error(`Remote Consensus request failed: ${response.status} ${text}`);
+    }
+    return {
+        id: typeof parsedBody.id === 'string' ? parsedBody.id : undefined,
+        conversationId: extractConversationId(parsedBody),
+        body: parsedBody,
+    };
+}
+function extractConversationId(body) {
+    if (typeof body.conversation === 'string')
+        return body.conversation;
+    if (body.conversation
+        && typeof body.conversation === 'object'
+        && 'id' in body.conversation
+        && typeof body.conversation.id === 'string') {
+        return body.conversation.id;
+    }
+    return undefined;
+}
+function parseRemoteConsensusPayload(body) {
+    if (isRecord(body) && typeof body.status === 'string') {
+        return body;
+    }
+    if (isRecord(body) && typeof body.output_text === 'string') {
+        return parseJsonMaybe(body.output_text);
+    }
+    if (isRecord(body) && Array.isArray(body.output)) {
+        for (const item of body.output) {
+            if (!isRecord(item) || !Array.isArray(item.content))
+                continue;
+            for (const content of item.content) {
+                if (!isRecord(content))
+                    continue;
+                const text = typeof content.text === 'string'
+                    ? content.text
+                    : typeof content.output_text === 'string'
+                        ? content.output_text
+                        : undefined;
+                if (!text)
+                    continue;
+                const parsed = parseJsonMaybe(text);
+                if (parsed)
+                    return parsed;
+            }
+        }
+    }
+    if (isRecord(body) && Array.isArray(body.choices)) {
+        for (const choice of body.choices) {
+            if (!isRecord(choice) || !isRecord(choice.message))
+                continue;
+            if (typeof choice.message.content !== 'string')
+                continue;
+            const parsed = parseJsonMaybe(choice.message.content);
+            if (parsed)
+                return parsed;
+        }
+    }
+    return undefined;
+}
+function coerceResolvedConsensusPayload(payload) {
+    if (!isRecord(payload) || payload.status !== 'resolved')
+        return null;
+    const schemaUri = stringField(payload, 'schemaUri') ?? stringField(payload, 'uri');
+    if (schemaUri !== XPOD_CREDENTIAL.Credential)
+        return null;
+    if (!isRecord(payload.fieldMapping))
+        return null;
+    const service = stringField(payload.fieldMapping, 'service');
+    const providerId = stringField(payload.fieldMapping, 'providerId');
+    const secretType = stringField(payload.fieldMapping, 'secretType');
+    if (!service || !providerId || !secretType)
+        return null;
+    return {
+        fieldMapping: {
+            service,
+            providerId,
+            secretType,
+            label: stringField(payload.fieldMapping, 'label'),
+            status: stringField(payload.fieldMapping, 'status'),
+        },
+        confidence: typeof payload.confidence === 'number' ? payload.confidence : undefined,
+    };
+}
+function parseJsonMaybe(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function stringField(record, field) {
+    const value = record[field];
+    return typeof value === 'string' && value.trim() ? value : undefined;
+}
+function buildConsensusResult(input) {
+    const first = {
+        status: 'needs_clarification',
+        questions: [
+            {
+                id: 'token_type',
+                question: '这是 Cloudflare API Token 还是 Tunnel Token？',
+                options: ['tunnel-token', 'api-token'],
+            },
+        ],
+    };
+    const resolved = {
+        status: 'resolved',
+        schemaUri: XPOD_CREDENTIAL.Credential,
+        fieldMapping: {
+            service: input.fieldMapping?.service ?? 'infra',
+            providerId: input.fieldMapping?.providerId ?? 'cloudflare',
+            secretType: input.fieldMapping?.secretType ?? input.tokenType,
+            label: input.fieldMapping?.label
+                ?? defaultCredentialLabel(input.fieldMapping?.providerId ?? 'cloudflare', input.fieldMapping?.secretType ?? input.tokenType),
+            status: input.fieldMapping?.status ?? 'active',
+        },
+        confidence: input.confidence ?? (input.tokenType === 'tunnel-token' ? 0.96 : 0.94),
+    };
+    const descriptor = podSchema.describe({ uri: resolved.schemaUri });
+    if (!descriptor) {
+        throw new Error(`Descriptor not found: ${resolved.schemaUri}`);
+    }
+    return {
+        session_id: input.sessionId,
+        consensusRuntime: input.runtime,
+        consensusResponse: input.response,
+        first,
+        resolved,
+        descriptor: {
+            uri: descriptor.uri,
+            storage: descriptor.storage,
+        },
+    };
+}
+function readOption(args, name) {
+    const index = args.indexOf(name);
+    if (index === -1)
+        return undefined;
+    const value = args[index + 1];
+    return value && !value.startsWith('--') ? value : undefined;
+}
+function readNumberOption(args, name) {
+    const value = readOption(args, name);
+    if (!value)
+        return undefined;
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+        throw new Error(`${name} must be a positive number`);
+    }
+    return Math.floor(parsed);
+}
+function readConsensusInput(args) {
+    if (args[0] === 'model') {
+        throw new Error('Use: udfs consensus --input \'<json>\'');
+    }
+    const parsed = readInputPayload(args, 'udfs consensus --input \'<json>\' --json');
+    if (!isRecord(parsed)) {
+        throw new Error('Consensus input must be a JSON object');
+    }
+    const request = stringField(parsed, 'request')
+        ?? stringField(parsed, 'message')
+        ?? stringField(parsed, 'text');
+    if (!request) {
+        throw new Error('Consensus input requires a non-empty request field');
+    }
+    const answers = isRecord(parsed.answers) ? parsed.answers : {};
+    const tokenTypeText = stringField(answers, 'token_type') ?? stringField(parsed, 'token_type');
+    const tokenType = coerceTokenType(tokenTypeText);
+    if (tokenTypeText && !tokenType) {
+        throw new Error(`Unsupported token type: ${tokenTypeText}`);
+    }
+    return {
+        session_id: stringField(parsed, 'session_id'),
+        request,
+        answers: tokenType ? { token_type: tokenType } : undefined,
+        conversation_id: stringField(parsed, 'conversation_id') ?? stringField(parsed, 'conversation'),
+    };
+}
+function coerceTokenType(value) {
+    if (value === 'tunnel-token' || value === 'api-token') {
+        return value;
+    }
+    return undefined;
+}
+function defaultCredentialLabel(providerId, secretType) {
+    const providerLabel = providerId
+        .split(/[-_.]/g)
+        .filter(Boolean)
+        .map((part) => `${part.slice(0, 1).toUpperCase()}${part.slice(1)}`)
+        .join(' ');
+    const secretLabel = secretType
+        .split(/[-_.]/g)
+        .filter(Boolean)
+        .map((part) => part.toLowerCase() === 'api' ? 'API' : `${part.slice(0, 1).toUpperCase()}${part.slice(1)}`)
+        .join(' ');
+    return `${providerLabel} ${secretLabel}`;
+}
+function readInputPayload(args, usage) {
+    const raw = readOption(args, '--input');
+    if (!raw) {
+        throw new Error(`Usage: ${usage}`);
+    }
+    return JSON.parse(raw);
+}
+function writeJson(value) {
+    process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
+}
+function printHelp() {
+    process.stdout.write(`udfs - Undefineds Pod data semantics tool
+
+Usage:
+  udfs schema list
+  udfs schema search --query <text>
+  udfs schema describe <uri>
+  udfs schema classes [--uri <uri>]
+  udfs schema predicates [--uri <uri>] [--field <field>]
+  udfs consensus --input '{"session_id":"sess_123","request":"我要保存这个 Cloudflare token","answers":{"token_type":"tunnel-token"}}' --json
+  udfs storage validate --input '<mutation-json>'
+
+Runtime:
+  Remote Consensus uses UDFS_CONSENSUS_BASE_URL plus UDFS_CONSENSUS_TOKEN when injected by LinX/linx-lite.
+  Do not pass user API keys on the command line.
+`);
+}
+function printConsensusHelp() {
+    process.stdout.write(`udfs consensus - Ask Consensus how a storage request should be represented
+
+Usage:
+  udfs consensus --input '{"session_id":"sess_123","request":"我要保存这个 Cloudflare token","answers":{"token_type":"tunnel-token"}}' --json
+
+Runtime:
+  Remote Consensus uses UDFS_CONSENSUS_BASE_URL plus UDFS_CONSENSUS_TOKEN when injected by LinX/linx-lite.
+`);
+}
+main(process.argv.slice(2)).catch((error) => {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+    process.exitCode = 1;
+});

package/dist/chat.repository.d.ts

@@ -3,6 +3,8 @@ export declare const chatRepository: import("@undefineds.co/drizzle-solid/dist/c
     title: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, true, false>;
     description: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, false, false>;
     avatarUrl: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"uri", null, false, false>;
+    author: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"uri", null, false, false>;
+    status: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, true, true>;
     starred: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"boolean", null, false, true>;
     muted: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"boolean", null, false, true>;
     unreadCount: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"integer", null, false, true>;
@@ -19,6 +21,8 @@ export declare const chatRepository: import("@undefineds.co/drizzle-solid/dist/c
     title: string;
     description: string;
     avatarUrl: string;
+    author: string;
+    status: string;
     starred: boolean;
     muted: boolean;
     unreadCount: number;
@@ -35,6 +39,8 @@ export declare const chatRepository: import("@undefineds.co/drizzle-solid/dist/c
     id?: string | undefined;
     description?: string | undefined;
     avatarUrl?: string | undefined;
+    author?: string | undefined;
+    status?: string | undefined;
     starred?: boolean | undefined;
     muted?: boolean | undefined;
     unreadCount?: number | undefined;
@@ -51,6 +57,8 @@ export declare const chatRepository: import("@undefineds.co/drizzle-solid/dist/c
     title?: string | undefined;
     description?: string | null | undefined;
     avatarUrl?: string | null | undefined;
+    author?: string | null | undefined;
+    status?: string | undefined;
     starred?: boolean | null | undefined;
     muted?: boolean | null | undefined;
     unreadCount?: number | null | undefined;

package/dist/chat.schema.d.ts

@@ -1,4 +1,10 @@
 export type ChatMemberRole = 'owner' | 'admin' | 'member';
+export type ChatStatusType = 'active' | 'archived' | 'deleted';
+export declare const ChatStatus: {
+    readonly ACTIVE: "active";
+    readonly ARCHIVED: "archived";
+    readonly DELETED: "deleted";
+};
 export interface ChatMetadata {
     memberRoles?: Record<string, ChatMemberRole>;
 }
@@ -24,6 +30,8 @@ export declare const chatResource: import("@undefineds.co/drizzle-solid/dist/cor
     title: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, true, false>;
     description: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, false, false>;
     avatarUrl: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"uri", null, false, false>;
+    author: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"uri", null, false, false>;
+    status: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, true, true>;
     starred: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"boolean", null, false, true>;
     muted: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"boolean", null, false, true>;
     unreadCount: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"integer", null, false, true>;
@@ -41,6 +49,8 @@ export declare const chatTable: import("@undefineds.co/drizzle-solid/dist/core/s
     title: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, true, false>;
     description: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, false, false>;
     avatarUrl: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"uri", null, false, false>;
+    author: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"uri", null, false, false>;
+    status: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, true, true>;
     starred: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"boolean", null, false, true>;
     muted: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"boolean", null, false, true>;
     unreadCount: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"integer", null, false, true>;

package/dist/chat.schema.js

@@ -1,5 +1,11 @@
 import { boolean, object, podTable, string, text, timestamp, uri, id, integer } from '@undefineds.co/drizzle-solid';
 import { UDFS, DCTerms, SCHEMA, MEETING, WF } from './namespaces.js';
+import { chatResourceId } from './resource-id-defaults.js';
+export const ChatStatus = {
+    ACTIVE: 'active',
+    ARCHIVED: 'archived',
+    DELETED: 'deleted',
+};
 /**
  * Chat resource.
  *
@@ -18,12 +24,14 @@ import { UDFS, DCTerms, SCHEMA, MEETING, WF } from './namespaces.js';
  * - Threads stored as fragments in same file: /.data/chat/{id}/index.ttl#{threadId}
  */
 export const chatResource = podTable('chats', {
-    id: id('id'),
+    id: id('id').default(chatResourceId),
     // Display
     title: string('title').predicate(DCTerms.title).notNull(),
     description: string('description').predicate(DCTerms.description),
     avatarUrl: uri('avatarUrl').predicate(SCHEMA.image),
     // Chat state
+    author: uri('author').predicate(DCTerms.creator),
+    status: string('status').predicate(UDFS.status).notNull().default(ChatStatus.ACTIVE),
     starred: boolean('starred').predicate(UDFS.favorite).default(false),
     muted: boolean('muted').predicate(UDFS.muted).default(false),
     unreadCount: integer('unreadCount').predicate(UDFS.unreadCount).default(0),
@@ -49,7 +57,6 @@ export const chatResource = podTable('chats', {
     sparqlEndpoint: '/.data/chat/-/sparql',
     type: MEETING.LongChat,
     namespace: UDFS,
-    subjectTemplate: '{id}/index.ttl#this',
 });
 // Compatibility alias. New model code should prefer `chatResource`.
 export const chatTable = chatResource;

package/dist/chat.utils.js

@@ -1,6 +1,5 @@
-import { extractPodResourceTemplateValue, parsePodResourceRef } from '@undefineds.co/drizzle-solid';
-import { chatResource } from './chat.schema.js';
-import { threadResource } from './thread.schema.js';
+import { parsePodResourceRef } from '@undefineds.co/drizzle-solid';
+import { commandKindFromResourceId, surfaceIdFromCommandResourceId, } from './resource-id-defaults.js';
 export const toTimestamp = (value, fallback = 0) => {
     if (value instanceof Date)
         return value.getTime();
@@ -13,19 +12,35 @@ export const toTimestamp = (value, fallback = 0) => {
     return fallback;
 };
 export function extractChatIdFromChatRef(chatRef) {
-    return extractPodResourceTemplateValue(threadResource, chatRef, 'chat')
-        ?? extractPodResourceTemplateValue(chatResource, chatRef);
+    if (!chatRef)
+        return null;
+    const parsed = parsePodResourceRef({ config: { base: '/.data/chat/' } }, chatRef);
+    const resourceId = parsed?.resourceId ?? chatRef;
+    const direct = resourceId.match(/^([^/]+)\/index\.ttl#this$/);
+    if (direct)
+        return decodeURIComponent(direct[1]);
+    return surfaceIdFromCommandResourceId(resourceId);
 }
 export function extractThreadIdFromThreadRef(threadRef) {
-    return extractPodResourceTemplateValue(threadResource, threadRef);
+    if (!threadRef)
+        return null;
+    const parsed = parsePodResourceRef({ config: { base: '/.data/' } }, threadRef);
+    const resourceId = parsed?.resourceId ?? threadRef;
+    const hashIndex = resourceId.lastIndexOf('#');
+    return hashIndex >= 0 && hashIndex < resourceId.length - 1
+        ? resourceId.slice(hashIndex + 1)
+        : resourceId;
 }
 export function extractChatThreadRef(uri) {
     if (!uri)
         return { chatId: null, threadId: null };
-    const parsed = parsePodResourceRef(threadResource, uri);
+    const parsed = parsePodResourceRef({ config: { base: '/.data/' } }, uri);
+    const resourceId = parsed?.resourceId ?? uri;
     return {
-        chatId: parsed?.templateValues.chat ?? null,
-        threadId: parsed?.templateValues.id ?? null,
+        chatId: commandKindFromResourceId(resourceId) === 'chat'
+            ? surfaceIdFromCommandResourceId(resourceId)
+            : null,
+        threadId: extractThreadIdFromThreadRef(resourceId),
     };
 }
 export function resolveThreadChatId(thread) {

package/dist/index.d.ts

@@ -5,13 +5,16 @@ export * from './profile.repository';
 export * from './profile.schema';
 export { ContactGender, contactResource, contactTable, ContactClass, ContactType, isAgentContact, isGroupContact, normalizeContactGender, type ContactRow, type ContactInsert, type ContactUpdate, type ContactClassValue, type ContactGenderValue, type ContactTypeValue, } from './contact.schema';
 export { contactRepository } from './contact.repository';
-export { chatResource, chatTable, type ChatMetadata, type ChatMemberRole, type ChatRow, type ChatInsert, type ChatUpdate, } from './chat.schema';
+export { ChatStatus, chatResource, chatTable, type ChatMetadata, type ChatMemberRole, type ChatStatusType, type ChatRow, type ChatInsert, type ChatUpdate, } from './chat.schema';
 export { chatRepository } from './chat.repository';
 export { extractChatIdFromChatRef, extractChatThreadRef, extractThreadIdFromThreadRef, resolveThreadChatId, toTimestamp, type ChatThreadRef, } from './chat.utils';
-export { threadResource, threadTable, type ThreadRow, type ThreadInsert, type ThreadUpdate, } from './thread.schema';
+export { ThreadStatus, threadResource, threadTable, type ThreadStatusType, type ThreadRow, type ThreadInsert, type ThreadUpdate, } from './thread.schema';
 export { threadRepository } from './thread.repository';
-export { messageResource, messageTable, type MessageRow, type MessageInsert, type MessageUpdate, } from './message.schema';
+export { MessageRole, MessageStatus, messageResource, messageTable, type MessageRoleType, type MessageStatusType, type MessageRow, type MessageInsert, type MessageUpdate, } from './message.schema';
 export { messageRepository } from './message.repository';
+export { TaskStatus, TaskTriggerKind, taskResource, taskTable, type TaskStatusType, type TaskTriggerKindType, type TaskRow, type TaskInsert, type TaskUpdate, } from './task.schema';
+export { RunStatus, RunStepType, runResource, runStepResource, runTable, runStepTable, type RunStatusType, type RunStepTypeValue, type RunRow, type RunInsert, type RunUpdate, type RunStepRow, type RunStepInsert, type RunStepUpdate, } from './run.schema';
+export { chatResourceId, commandKindFromResourceId, dateParts, messageResourceId, parentDir, resourceKey, runResourceId, runStepResourceId, surfaceIdFromCommandResourceId, taskResourceId, threadResourceId, type CommandKind, type DateInput, type DateParts, } from './resource-id-defaults';
 export { issueResource, issueTable, type IssueStatus, type IssuePriority, type IssueRow, type IssueInsert, type IssueUpdate, } from './issue.schema';
 export { issueRepository } from './issue.repository';
 export { MessageBlockType, MessageBlockStatus, type BaseMessageBlock, type PlaceholderMessageBlock, type MainTextMessageBlock, type ThinkingMessageBlock, type ImageMessageBlock, type CodeMessageBlock, type ToolMessageBlock, type FileMessageBlock, type ErrorMessageBlock, type CitationMessageBlock, type MessageBlock, type MessageRichContent, createMessageBlock, isBlockType, parseMessageBlocks, serializeMessageBlocks, } from './types/message-block';
@@ -41,6 +44,7 @@ export { aiModelResource, aiModelTable, type AIModelRow, type AIModelInsert, typ
 export { agentStatusResource, agentStatusTable, aiConfigResource, aiConfigTable, indexedFileResource, indexedFileTable, vectorStoreResource, vectorStoreTable, type AgentStatusRow, type AgentStatusInsert, type AgentStatusUpdate, type AIConfigRow, type AIConfigInsert, type AIConfigUpdate as AIConfigResourceUpdate, type IndexedFileRow, type IndexedFileInsert, type IndexedFileUpdate, type VectorStoreRow, type VectorStoreInsert, type VectorStoreUpdate, } from './ai-runtime.schema';
 export { aiConfigModelRef, aiConfigModelUri, aiConfigProviderRef, aiConfigProviderUri, buildAIConfigDisconnectPlan, buildAIConfigMutationPlan, buildAIConfigProviderStateMap, getAIConfigDefaultBaseUrl, getAIConfigProviderCatalog, getAIConfigProviderFamilyIds, getAIConfigProviderMetadata, getDefaultAIConfigCredentialId, normalizeAIConfigProviderId, normalizeAIConfigModelId, normalizeAIConfigResourceId, sameAIConfigProviderFamily, selectAIConfigCredential, type AIConfigModel, type AIConfigCredentialSelection, type AIConfigDisconnectPlan, type AIConfigMutationPlan, type AIConfigProviderCatalogEntry, type AIConfigProviderState, type AIConfigUpdate, type BuildAIConfigProviderStateMapOptions, } from './ai-config';
 export { applySolidComunicaPatches, } from './comunica-patches';
+export { credentialDescriptor, createPodModelDescriptorRegistry, createPodSchema, createPodStorage, officialPodModelDescriptors, podSchema, type PodModelDescriptor, type PodModelDescriptorSource, type PodModelDescriptorTrustLevel, type PodModelFieldDescriptor, type PodModelFieldType, type PodModelMergePolicy, type PodSchemaClassEntry, type PodSchemaPredicateEntry, type PodSchemaSearchEntry, type PodStorageCommitResult, type PodStorageMutationPlan, type PodStorageValidationResult, } from './pod-storage-descriptor';
 export { createRepositoryDescriptor, definePodRepository, initSolidResources, initSolidTables, type AnyPodResource, type AnyPodTable, type PodRepositoryDescriptor, type RepositoryCacheOptions, type RepositoryInvalidations, type RepositoryScope, type SolidDatabase, } from './repository';
 export { importJobSchema } from './import';
 export { eq, ne, and, or, drizzle } from '@undefineds.co/drizzle-solid';