@undefineds.co/models 0.2.26 → 0.2.28

package/dist/pod-storage-descriptor.js

@@ -0,0 +1,283 @@
+import { XPOD_CREDENTIAL } from './namespaces.js';
+export const credentialDescriptor = {
+    uri: XPOD_CREDENTIAL.Credential,
+    version: '1.0.0',
+    source: 'official',
+    trustLevel: 'high',
+    namespace: XPOD_CREDENTIAL.NAMESPACE,
+    class: XPOD_CREDENTIAL.Credential,
+    resourceKind: 'credential',
+    description: 'Generic credential material required by runtimes, tools, MCP servers, and providers.',
+    storage: {
+        base: '/settings/credentials.ttl',
+        resourceIdPattern: '#{id}',
+        subjectTemplate: '#{id}',
+    },
+    fields: {
+        id: {
+            type: 'string',
+            predicate: XPOD_CREDENTIAL.term('id'),
+            required: true,
+            description: 'Local credential id.',
+        },
+        service: {
+            type: 'string',
+            predicate: XPOD_CREDENTIAL.service,
+            required: true,
+            description: 'Credential service grouping, for example ai or infra.',
+        },
+        providerId: {
+            type: 'string',
+            predicate: XPOD_CREDENTIAL.provider,
+            required: true,
+            description: 'Provider identifier such as openai or cloudflare.',
+        },
+        secretType: {
+            type: 'string',
+            predicate: XPOD_CREDENTIAL.term('secretType'),
+            required: true,
+            description: 'Provider-specific secret kind such as api-key or tunnel-token.',
+        },
+        label: {
+            type: 'string',
+            predicate: XPOD_CREDENTIAL.label,
+            description: 'User-facing credential label.',
+        },
+        apiKey: {
+            type: 'string',
+            predicate: XPOD_CREDENTIAL.apiKey,
+            secret: true,
+            description: 'Secret token or API key material.',
+        },
+        status: {
+            type: 'string',
+            predicate: XPOD_CREDENTIAL.status,
+            description: 'Credential health status.',
+        },
+    },
+    uniqueBy: ['service', 'providerId', 'secretType'],
+    writableFields: ['label', 'apiKey', 'status'],
+    mergePolicy: 'upsert',
+    examples: [
+        {
+            request: '保存 Cloudflare tunnel token',
+            match: {
+                service: 'infra',
+                providerId: 'cloudflare',
+                secretType: 'tunnel-token',
+            },
+        },
+        {
+            request: '保存 OpenAI API key',
+            match: {
+                service: 'ai',
+                providerId: 'openai',
+                secretType: 'api-key',
+            },
+        },
+    ],
+};
+export const officialPodModelDescriptors = [credentialDescriptor];
+export function createPodModelDescriptorRegistry(descriptors = officialPodModelDescriptors) {
+    const byUri = new Map(descriptors.map((descriptor) => [descriptor.uri, descriptor]));
+    return {
+        list(filter = {}) {
+            return descriptors.filter((descriptor) => {
+                if (filter.source && descriptor.source !== filter.source)
+                    return false;
+                if (filter.resourceKind && descriptor.resourceKind !== filter.resourceKind)
+                    return false;
+                return true;
+            });
+        },
+        describe(uri) {
+            return byUri.get(uri) ?? null;
+        },
+    };
+}
+export const podSchema = createPodSchema();
+export function createPodSchema(registry = createPodModelDescriptorRegistry()) {
+    const resolveDescriptors = (input = {}) => {
+        const uri = input.uri ?? input.schemaUri;
+        if (!uri)
+            return registry.list();
+        const descriptor = registry.describe(uri);
+        return descriptor ? [descriptor] : [];
+    };
+    return {
+        list: registry.list,
+        describe(uriOrInput) {
+            const uri = typeof uriOrInput === 'string'
+                ? uriOrInput
+                : 'uri' in uriOrInput
+                    ? uriOrInput.uri
+                    : uriOrInput.schemaUri;
+            return registry.describe(uri);
+        },
+        classes(input = {}) {
+            return resolveDescriptors(input).map((descriptor) => ({
+                schemaUri: descriptor.uri,
+                resourceKind: descriptor.resourceKind,
+                class: descriptor.class,
+                namespace: descriptor.namespace,
+                source: descriptor.source,
+                trustLevel: descriptor.trustLevel,
+                description: descriptor.description,
+            }));
+        },
+        search(input) {
+            const terms = normalizeSearchTerms(input.query);
+            if (terms.length === 0)
+                return [];
+            return registry.list({
+                source: input.source,
+                resourceKind: input.resourceKind,
+            })
+                .map((descriptor) => scoreDescriptorSearch(descriptor, terms))
+                .filter((entry) => entry !== null)
+                .sort((a, b) => b.score - a.score || a.uri.localeCompare(b.uri))
+                .slice(0, Math.max(1, input.limit ?? 10));
+        },
+        predicates(input = {}) {
+            return resolveDescriptors(input).flatMap((descriptor) => (Object.entries(descriptor.fields)
+                .filter(([field]) => !input.field || field === input.field)
+                .map(([field, descriptorField]) => ({
+                schemaUri: descriptor.uri,
+                field,
+                predicate: descriptorField.predicate,
+                type: descriptorField.type,
+                required: Boolean(descriptorField.required),
+                secret: Boolean(descriptorField.secret),
+                array: Boolean(descriptorField.array),
+                description: descriptorField.description,
+            }))));
+        },
+    };
+}
+export function createPodStorage(registry = createPodModelDescriptorRegistry(), store = new Map()) {
+    const plans = new Map();
+    return {
+        validate(input) {
+            const schemaUri = input.schemaUri;
+            if (!schemaUri)
+                return invalid('schema_uri_required', 'Missing schemaUri');
+            const descriptor = registry.describe(schemaUri);
+            if (!descriptor)
+                return invalid('descriptor_not_found', `Descriptor not found: ${schemaUri}`);
+            if (input.operation !== 'upsert')
+                return invalid('unsupported_operation', `Unsupported operation: ${input.operation}`);
+            const missingKeys = descriptor.uniqueBy.filter((field) => !input.match[field]);
+            if (missingKeys.length > 0) {
+                return invalid('missing_match_fields', `Missing match fields: ${missingKeys.join(', ')}`);
+            }
+            const set = input.set ?? {};
+            const invalidSetFields = Object.keys(set).filter((field) => !descriptor.writableFields.includes(field));
+            if (invalidSetFields.length > 0) {
+                return invalid('invalid_set_fields', `Fields are not writable: ${invalidSetFields.join(', ')}`);
+            }
+            const resourceId = buildResourceId(descriptor, input.match);
+            const plan = {
+                id: `plan_${resourceId.replace(/[^a-zA-Z0-9_.-]+/g, '-')}`,
+                schemaUri: descriptor.uri,
+                operation: input.operation,
+                resourceId,
+                resourceUri: buildResourceUri(descriptor, resourceId),
+                match: input.match,
+                set,
+                summary: `Upsert ${descriptor.resourceKind} for ${descriptor.uniqueBy.map((field) => input.match[field]).join('/')}`,
+            };
+            plans.set(plan.id, plan);
+            return { ok: true, plan };
+        },
+        commit(input) {
+            const plan = plans.get(input.planId);
+            if (!plan)
+                return invalid('plan_not_found', `Plan not found: ${input.planId}`);
+            const existing = store.get(plan.resourceUri) ?? {};
+            const resource = {
+                ...existing,
+                ...plan.match,
+                ...plan.set,
+                schemaUri: plan.schemaUri,
+                resourceId: plan.resourceId,
+                resourceUri: plan.resourceUri,
+            };
+            store.set(plan.resourceUri, resource);
+            return { ok: true, resource };
+        },
+        read(input) {
+            const resource = store.get(input.resourceUri);
+            if (!resource)
+                return invalid('resource_not_found', `Resource not found: ${input.resourceUri}`);
+            return { ok: true, resource };
+        },
+        store,
+        plans,
+    };
+}
+function invalid(code, message) {
+    return {
+        ok: false,
+        error: { code, message },
+    };
+}
+function buildResourceId(descriptor, match) {
+    const raw = descriptor.uniqueBy.map((field) => String(match[field])).join('-');
+    const localId = raw.replace(/[^a-zA-Z0-9_.-]+/g, '-');
+    return descriptor.storage.resourceIdPattern.replace('{id}', localId);
+}
+function buildResourceUri(descriptor, resourceId) {
+    return `${descriptor.storage.base}${resourceId}`;
+}
+function normalizeSearchTerms(query) {
+    return query
+        .toLowerCase()
+        .split(/[\s,;:/#._-]+/u)
+        .map((term) => term.trim())
+        .filter(Boolean);
+}
+function scoreDescriptorSearch(descriptor, terms) {
+    const matchedFields = new Set();
+    let score = 0;
+    const match = (field, value, weight) => {
+        if (!value)
+            return;
+        const normalized = value.toLowerCase();
+        for (const term of terms) {
+            if (!normalized.includes(term))
+                continue;
+            matchedFields.add(field);
+            score += weight;
+        }
+    };
+    match('uri', descriptor.uri, 10);
+    match('class', descriptor.class, 10);
+    match('namespace', descriptor.namespace, 4);
+    match('resourceKind', descriptor.resourceKind, 8);
+    match('description', descriptor.description, 4);
+    match('storage', `${descriptor.storage.base}${descriptor.storage.resourceIdPattern}`, 3);
+    for (const [fieldName, field] of Object.entries(descriptor.fields)) {
+        match(`field:${fieldName}`, fieldName, 6);
+        match(`predicate:${fieldName}`, field.predicate, 6);
+        match(`description:${fieldName}`, field.description, 3);
+    }
+    for (const example of descriptor.examples) {
+        match('example', example.request, 3);
+        for (const [fieldName, value] of Object.entries(example.match)) {
+            match(`example:${fieldName}`, String(value), 3);
+        }
+    }
+    if (score <= 0)
+        return null;
+    return {
+        uri: descriptor.uri,
+        resourceKind: descriptor.resourceKind,
+        class: descriptor.class,
+        namespace: descriptor.namespace,
+        source: descriptor.source,
+        trustLevel: descriptor.trustLevel,
+        description: descriptor.description,
+        score,
+        matchedFields: [...matchedFields].sort(),
+    };
+}

package/dist/repository.d.ts

@@ -4,3 +4,5 @@ export { initSolidTables };
 export type { AnyPodTable };
 export declare const initSolidResources: typeof initSolidTables;
 export type AnyPodResource = AnyPodTable;
+type PodResourceTemplateTarget = Parameters<typeof import('@undefineds.co/drizzle-solid').extractPodResourceTemplateValue>[0];
+export declare function asPodResourceTemplateTarget(resource: AnyPodResource): PodResourceTemplateTarget;

package/dist/repository.js

@@ -4,3 +4,6 @@ export { initSolidTables };
 // Resource-first aliases for shared Solid model call sites. The underlying
 // drizzle-solid API still uses table-shaped arguments for compatibility.
 export const initSolidResources = initSolidTables;
+export function asPodResourceTemplateTarget(resource) {
+    return resource;
+}

package/dist/resource-id-defaults.d.ts

@@ -0,0 +1,18 @@
+export type CommandKind = 'chat' | 'task';
+export type DateInput = Date | string | number | null | undefined;
+export interface DateParts {
+    yyyy: string;
+    MM: string;
+    dd: string;
+}
+export declare function dateParts(value?: DateInput): DateParts;
+export declare function resourceKey(key: string | undefined, prefix: string): string;
+export declare function parentDir(id: string | null | undefined): string | null;
+export declare function surfaceIdFromCommandResourceId(id: string | null | undefined): string | null;
+export declare function commandKindFromResourceId(id: string | null | undefined): CommandKind | null;
+export declare function chatResourceId(key?: string): string;
+export declare function taskResourceId(key?: string): string;
+export declare function threadResourceId(key: string | undefined, row?: Record<string, unknown>): string;
+export declare function messageResourceId(key: string | undefined, row?: Record<string, unknown>): string;
+export declare function runResourceId(key: string | undefined, row?: Record<string, unknown>): string;
+export declare function runStepResourceId(key: string | undefined, row?: Record<string, unknown>): string;

package/dist/resource-id-defaults.js

@@ -0,0 +1,84 @@
+export function dateParts(value) {
+    const date = value instanceof Date
+        ? value
+        : typeof value === 'string' || typeof value === 'number'
+            ? new Date(typeof value === 'number' && Math.abs(value) < 100000000000 ? value * 1000 : value)
+            : new Date();
+    const safeDate = Number.isFinite(date.getTime()) ? date : new Date();
+    return {
+        yyyy: String(safeDate.getUTCFullYear()),
+        MM: String(safeDate.getUTCMonth() + 1).padStart(2, '0'),
+        dd: String(safeDate.getUTCDate()).padStart(2, '0'),
+    };
+}
+export function resourceKey(key, prefix) {
+    return key && key.length > 0
+        ? key
+        : `${prefix}_${Math.random().toString(36).slice(2, 12)}`;
+}
+export function parentDir(id) {
+    if (!id)
+        return null;
+    const hashless = id.split('#')[0] ?? id;
+    const parts = hashless.split('/').filter(Boolean);
+    if (parts.length <= 1)
+        return null;
+    return parts.slice(0, -1).join('/');
+}
+export function surfaceIdFromCommandResourceId(id) {
+    if (!id)
+        return null;
+    const match = id.match(/^(chat|task)\/([^/]+)\//);
+    return match ? decodeURIComponent(match[2]) : null;
+}
+export function commandKindFromResourceId(id) {
+    if (!id)
+        return null;
+    const match = id.match(/^(chat|task)\//);
+    return match?.[1] === 'task' ? 'task' : match?.[1] === 'chat' ? 'chat' : null;
+}
+export function chatResourceId(key) {
+    return `${resourceKey(key, 'chat')}/index.ttl#this`;
+}
+export function taskResourceId(key) {
+    return `index.ttl#${resourceKey(key, 'task')}`;
+}
+export function threadResourceId(key, row) {
+    const localKey = resourceKey(key, 'thread');
+    const commandKind = row?.commandKind === 'task' ? 'task' : 'chat';
+    const surfaceId = typeof row?.surfaceId === 'string' && row.surfaceId.length > 0
+        ? row.surfaceId
+        : surfaceIdFromCommandResourceId(typeof row?.id === 'string' ? row.id : undefined) ?? 'default';
+    return `${commandKind}/${surfaceId}/index.ttl#${localKey}`;
+}
+export function messageResourceId(key, row) {
+    const localKey = resourceKey(key, 'msg');
+    const commandKind = row?.commandKind === 'task' ? 'task' : 'chat';
+    const surfaceId = typeof row?.surfaceId === 'string' && row.surfaceId.length > 0
+        ? row.surfaceId
+        : surfaceIdFromCommandResourceId(typeof row?.thread === 'string' ? row.thread : undefined) ?? 'default';
+    const { yyyy, MM, dd } = dateParts(row?.createdAt);
+    return `${commandKind}/${surfaceId}/${yyyy}/${MM}/${dd}/messages.ttl#${localKey}`;
+}
+export function runResourceId(key, row) {
+    const localKey = resourceKey(key, 'run');
+    const commandKind = row?.commandKind === 'task' ? 'task' : 'chat';
+    const surfaceId = typeof row?.surfaceId === 'string' && row.surfaceId.length > 0
+        ? row.surfaceId
+        : surfaceIdFromCommandResourceId(typeof row?.thread === 'string' ? row.thread : undefined) ?? 'default';
+    const { yyyy, MM, dd } = dateParts(row?.createdAt);
+    return `${commandKind}/${surfaceId}/${yyyy}/${MM}/${dd}/runs.ttl#${localKey}`;
+}
+export function runStepResourceId(key, row) {
+    const localKey = resourceKey(key, 'run-step');
+    const runId = typeof row?.runId === 'string' ? row.runId : undefined;
+    if (runId && /^(chat|task)\/[^/]+\/\d{4}\/\d{2}\/\d{2}\/runs\.ttl#[^#/]+$/.test(runId)) {
+        return `${runId.slice(0, runId.lastIndexOf('#') + 1)}${localKey}`;
+    }
+    const commandKind = row?.commandKind === 'task' ? 'task' : 'chat';
+    const surfaceId = typeof row?.surfaceId === 'string' && row.surfaceId.length > 0
+        ? row.surfaceId
+        : 'default';
+    const { yyyy, MM, dd } = dateParts(row?.createdAt);
+    return `${commandKind}/${surfaceId}/${yyyy}/${MM}/${dd}/runs.ttl#${localKey}`;
+}

package/dist/run.schema.d.ts

@@ -0,0 +1,112 @@
+export type RunStatusType = 'queued' | 'running' | 'waiting_input' | 'waiting_runner' | 'completed' | 'failed' | 'cancelled';
+export declare const RunStatus: {
+    readonly QUEUED: "queued";
+    readonly RUNNING: "running";
+    readonly WAITING_INPUT: "waiting_input";
+    readonly WAITING_RUNNER: "waiting_runner";
+    readonly COMPLETED: "completed";
+    readonly FAILED: "failed";
+    readonly CANCELLED: "cancelled";
+};
+export declare const RunStepType: {
+    readonly CREATED: "run.created";
+    readonly STARTED: "run.started";
+    readonly TEXT_DELTA: "runtime.text_delta";
+    readonly AUTH_REQUIRED: "runtime.auth_required";
+    readonly TOOL_CALL: "runtime.tool_call";
+    readonly WAITING_INPUT: "runtime.waiting_input";
+    readonly WAITING_RUNNER: "runtime.waiting_runner";
+    readonly CANCEL_REQUESTED: "run.cancel_requested";
+    readonly CANCELLED: "run.cancelled";
+    readonly ERROR: "runtime.error";
+    readonly COMPLETED: "run.completed";
+    readonly FAILED: "run.failed";
+    readonly CLIENT_TOOL_OUTPUT: "runtime.client_tool_output";
+    readonly CONTINUE_REQUESTED: "run.continue_requested";
+};
+export type RunStepTypeValue = (typeof RunStepType)[keyof typeof RunStepType];
+/**
+ * Run resource.
+ *
+ * Run is the durable execution fact for an Agent Runtime attempt. Chat and
+ * Task describe command shape; Run describes the concrete runtime execution.
+ */
+export declare const runResource: import("@undefineds.co/drizzle-solid/dist/core/schema").PodTableWithColumns<import("@undefineds.co/drizzle-solid/dist/core/schema").ResolvedColumns<{
+    id: import("@undefineds.co/drizzle-solid/dist/core/schema").PodStringColumn<false, false>;
+    commandKind: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, true, true>;
+    surfaceId: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, true, true>;
+    task: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"uri", null, false, false>;
+    thread: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"uri", null, true, false>;
+    workspace: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"uri", null, true, false>;
+    status: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, true, true>;
+    runner: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, true, false>;
+    prompt: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, false, false>;
+    externalRunId: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, false, false>;
+    leaseOwner: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, false, false>;
+    leaseExpiresAt: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"datetime", null, false, false>;
+    heartbeatAt: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"datetime", null, false, false>;
+    cancelRequestedAt: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"datetime", null, false, false>;
+    error: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, false, false>;
+    metadata: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"object", null, false, false>;
+    createdAt: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"datetime", null, true, true>;
+    startedAt: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"datetime", null, false, false>;
+    completedAt: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"datetime", null, false, false>;
+    updatedAt: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"datetime", null, true, true>;
+}>>;
+/**
+ * RunStep resource.
+ *
+ * Append-only execution facts emitted while a Run executes. `runId` is a
+ * denormalized base-relative id for fast lookup; `run` is the semantic RDF
+ * relation to the Run.
+ */
+export declare const runStepResource: import("@undefineds.co/drizzle-solid/dist/core/schema").PodTableWithColumns<import("@undefineds.co/drizzle-solid/dist/core/schema").ResolvedColumns<{
+    id: import("@undefineds.co/drizzle-solid/dist/core/schema").PodStringColumn<false, false>;
+    commandKind: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, true, true>;
+    surfaceId: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, true, true>;
+    runId: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, true, false>;
+    run: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"uri", null, true, false>;
+    type: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, true, false>;
+    message: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, false, false>;
+    data: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"object", null, false, false>;
+    createdAt: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"datetime", null, true, true>;
+}>>;
+export declare const runTable: import("@undefineds.co/drizzle-solid/dist/core/schema").PodTableWithColumns<import("@undefineds.co/drizzle-solid/dist/core/schema").ResolvedColumns<{
+    id: import("@undefineds.co/drizzle-solid/dist/core/schema").PodStringColumn<false, false>;
+    commandKind: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, true, true>;
+    surfaceId: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, true, true>;
+    task: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"uri", null, false, false>;
+    thread: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"uri", null, true, false>;
+    workspace: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"uri", null, true, false>;
+    status: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, true, true>;
+    runner: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, true, false>;
+    prompt: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, false, false>;
+    externalRunId: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, false, false>;
+    leaseOwner: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, false, false>;
+    leaseExpiresAt: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"datetime", null, false, false>;
+    heartbeatAt: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"datetime", null, false, false>;
+    cancelRequestedAt: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"datetime", null, false, false>;
+    error: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, false, false>;
+    metadata: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"object", null, false, false>;
+    createdAt: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"datetime", null, true, true>;
+    startedAt: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"datetime", null, false, false>;
+    completedAt: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"datetime", null, false, false>;
+    updatedAt: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"datetime", null, true, true>;
+}>>;
+export declare const runStepTable: import("@undefineds.co/drizzle-solid/dist/core/schema").PodTableWithColumns<import("@undefineds.co/drizzle-solid/dist/core/schema").ResolvedColumns<{
+    id: import("@undefineds.co/drizzle-solid/dist/core/schema").PodStringColumn<false, false>;
+    commandKind: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, true, true>;
+    surfaceId: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, true, true>;
+    runId: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, true, false>;
+    run: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"uri", null, true, false>;
+    type: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, true, false>;
+    message: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, false, false>;
+    data: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"object", null, false, false>;
+    createdAt: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"datetime", null, true, true>;
+}>>;
+export type RunRow = typeof runResource.$inferSelect;
+export type RunInsert = typeof runResource.$inferInsert;
+export type RunUpdate = typeof runResource.$inferUpdate;
+export type RunStepRow = typeof runStepResource.$inferSelect;
+export type RunStepInsert = typeof runStepResource.$inferInsert;
+export type RunStepUpdate = typeof runStepResource.$inferUpdate;

package/dist/run.schema.js

@@ -0,0 +1,89 @@
+import { id, object, podTable, string, timestamp, uri } from '@undefineds.co/drizzle-solid';
+import { DCTerms, UDFS } from './namespaces.js';
+import { taskResource } from './task.schema.js';
+import { threadResource } from './thread.schema.js';
+import { runResourceId, runStepResourceId } from './resource-id-defaults.js';
+export const RunStatus = {
+    QUEUED: 'queued',
+    RUNNING: 'running',
+    WAITING_INPUT: 'waiting_input',
+    WAITING_RUNNER: 'waiting_runner',
+    COMPLETED: 'completed',
+    FAILED: 'failed',
+    CANCELLED: 'cancelled',
+};
+export const RunStepType = {
+    CREATED: 'run.created',
+    STARTED: 'run.started',
+    TEXT_DELTA: 'runtime.text_delta',
+    AUTH_REQUIRED: 'runtime.auth_required',
+    TOOL_CALL: 'runtime.tool_call',
+    WAITING_INPUT: 'runtime.waiting_input',
+    WAITING_RUNNER: 'runtime.waiting_runner',
+    CANCEL_REQUESTED: 'run.cancel_requested',
+    CANCELLED: 'run.cancelled',
+    ERROR: 'runtime.error',
+    COMPLETED: 'run.completed',
+    FAILED: 'run.failed',
+    CLIENT_TOOL_OUTPUT: 'runtime.client_tool_output',
+    CONTINUE_REQUESTED: 'run.continue_requested',
+};
+/**
+ * Run resource.
+ *
+ * Run is the durable execution fact for an Agent Runtime attempt. Chat and
+ * Task describe command shape; Run describes the concrete runtime execution.
+ */
+export const runResource = podTable('run', {
+    id: id('id').default(runResourceId),
+    commandKind: string('commandKind').predicate(UDFS.commandKind).notNull().default('chat'),
+    surfaceId: string('surfaceId').predicate(UDFS.surfaceId).notNull().default('default'),
+    task: uri('task').predicate(UDFS.task).link(taskResource),
+    thread: uri('thread').predicate(UDFS.inThread).notNull().link(threadResource),
+    workspace: uri('workspace').predicate(UDFS.workspace).notNull(),
+    status: string('status').predicate(UDFS.status).notNull().default(RunStatus.QUEUED),
+    runner: string('runner').predicate(UDFS.runner).notNull(),
+    prompt: string('prompt').predicate(UDFS.prompt),
+    externalRunId: string('externalRunId').predicate(UDFS.externalRunId),
+    leaseOwner: string('leaseOwner').predicate(UDFS.leaseOwner),
+    leaseExpiresAt: timestamp('leaseExpiresAt').predicate(UDFS.leaseExpiresAt),
+    heartbeatAt: timestamp('heartbeatAt').predicate(UDFS.heartbeatAt),
+    cancelRequestedAt: timestamp('cancelRequestedAt').predicate(UDFS.cancelRequestedAt),
+    error: string('error').predicate(UDFS.error),
+    metadata: object('metadata').predicate(UDFS.metadata),
+    createdAt: timestamp('createdAt').predicate(DCTerms.created).notNull().defaultNow(),
+    startedAt: timestamp('startedAt').predicate(UDFS.startedAt),
+    completedAt: timestamp('completedAt').predicate(UDFS.completedAt),
+    updatedAt: timestamp('updatedAt').predicate(DCTerms.modified).notNull().defaultNow(),
+}, {
+    base: '/.data/',
+    sparqlEndpoint: '/.data/-/sparql',
+    type: UDFS.Run,
+    namespace: UDFS,
+});
+/**
+ * RunStep resource.
+ *
+ * Append-only execution facts emitted while a Run executes. `runId` is a
+ * denormalized base-relative id for fast lookup; `run` is the semantic RDF
+ * relation to the Run.
+ */
+export const runStepResource = podTable('run_step', {
+    id: id('id').default(runStepResourceId),
+    commandKind: string('commandKind').predicate(UDFS.commandKind).notNull().default('chat'),
+    surfaceId: string('surfaceId').predicate(UDFS.surfaceId).notNull().default('default'),
+    runId: string('runId').predicate(UDFS.runId).notNull(),
+    run: uri('run').predicate(UDFS.run).notNull().link(runResource),
+    type: string('type').predicate(UDFS.status).notNull(),
+    message: string('message').predicate(DCTerms.description),
+    data: object('data').predicate(UDFS.metadata),
+    createdAt: timestamp('createdAt').predicate(DCTerms.created).notNull().defaultNow(),
+}, {
+    base: '/.data/',
+    sparqlEndpoint: '/.data/-/sparql',
+    type: UDFS.RunStep,
+    namespace: UDFS,
+});
+// Compatibility aliases. New model code should prefer Resource names.
+export const runTable = runResource;
+export const runStepTable = runStepResource;