@native-knowledge/knowledge-sdk 0.0.0-stage → 0.1.0-rc.2

package/dist/internal/serving-contracts/tenant-runtime.js

@@ -0,0 +1,37 @@
+/** Provider20只增加明确授权的运行元数据；不扩展旧版本工具或授予正文读取。 */
+import { z } from 'zod';
+import { materialTenantIdSchema, isoDateTimeSchema, stableUriSchema, sha256Schema, projectKeySchema, tenantResourceRefSchema, tenantBudgetPolicySchema, tenantStorageKey, parseTenantResourceRef, parseTenantCollectionBatchRef, tenantBudgetReasonSchema } from '../contracts/index.js';
+import { tenantProjectWorkspaceToolSchemas, tenantProjectWorkspaceDataSchemas, tenantProjectScopesForInput, tenantProjectAuthorization, tenantProjectErrorSchema, tenantProjectProviderSchema } from './tenant-project.js';
+const count = z.number().int().nonnegative().safe(), cursor = z.string().min(1).max(4096), state = z.enum(['MATCH', 'MISSING', 'UNAVAILABLE', 'INTEGRITY_MISMATCH', 'NOT_REGISTERED']);
+export const tenantRuntimeKindSchema = z.enum(['REQUESTS', 'RESOURCES', 'PROJECTIONS', 'PROJECTS']);
+export const tenantRuntimeInputSchema = z.object({ kind: tenantRuntimeKindSchema.default('REQUESTS'), after: cursor.optional(), limit: z.number().int().min(1).max(20).default(20), requestRef: z.string().regex(/^tenant-collection-request:\/\/[a-f0-9]{64}\/[a-f0-9]{64}$/).optional() }).strict().superRefine((v, ctx) => { if (v.requestRef && (v.kind !== 'REQUESTS' || v.after))
+    ctx.addIssue({ code: 'custom', message: 'Exact request lookup requires REQUESTS without a page cursor' }); });
+export const tenantRuntimeProcessSchema = z.object({ runtimeNodeId: projectKeySchema, workloadId: z.string().min(1).max(256), runId: z.string().min(1).max(256), attribution: z.enum(['COMPLETION_RUN', 'FAILURE_RUN', 'SOURCE_WORKLOAD_LATEST', 'PROJECT_WORKLOAD_LATEST']), batchMatches: z.boolean().nullable(), outcome: z.enum(['SUCCEEDED', 'FAILED', 'TIMED_OUT', 'OUTPUT_LIMIT', 'SPAWN_FAILED', 'RECEIPT_MISSING']).nullable(), receiptStatus: z.enum(['SUCCEEDED', 'PARTIAL', 'FAILED', 'BLOCKED', 'SKIPPED']).nullable(), durationMs: count.nullable(), finishedAt: isoDateTimeSchema, category: z.enum(['NONE', 'TIMEOUT', 'OUTPUT_LIMIT', 'SPAWN_FAILURE', 'V8_HEAP_EXHAUSTED', 'NATIVE_ASSERTION_FAILURE', 'UNCAUGHT_EXCEPTION', 'PROCESS_SIGNAL', 'UNKNOWN_FAILURE']).nullable(), peakRssBytes: count.nullable(), sampleCount: count.nullable() }).strict();
+export const tenantRuntimeResourceSchema = z.object({ ref: tenantResourceRefSchema, contentHash: sha256Schema.nullable(), recordedBytes: count.nullable(), manifest: z.enum(['PRESENT', 'MISSING', 'UNAVAILABLE', 'INTEGRITY_MISMATCH']), blob: z.enum(['PRESENT_UNVERIFIED', 'MISSING', 'UNAVAILABLE', 'INTEGRITY_MISMATCH']), contentHashReverified: z.literal(false), catalog: state, directory: state, search: state }).strict();
+const request = z.object({ kind: z.literal('REQUESTS'), requestRef: stableUriSchema, batchRef: stableUriSchema, admission: z.enum(['PENDING', 'STOPPED', 'COMPLETED', 'FAILED']), failureCode: z.literal('TENANT_SOURCE_HTTP_TERMINAL').nullable().optional(), stopReason: z.enum(['GRANT_REVOKED', 'DELEGATION_SUPERSEDED']).nullable(), executionAuthority: z.enum(['CURRENT', 'BLOCKED', 'NOT_CONFIGURED', 'NOT_PENDING', 'UNAVAILABLE']), budgetReason: tenantBudgetReasonSchema.nullable(), captureRecord: z.enum(['PRESENT', 'MISSING', 'UNAVAILABLE']), raw: tenantRuntimeResourceSchema, derivation: z.enum(['NOT_REQUIRED', 'REGISTERED', 'PENDING', 'UNAVAILABLE']), completedPhase: z.enum(['RAW_REGISTERED', 'DERIVED_REGISTERED']).nullable(), process: tenantRuntimeProcessSchema.nullable() }).strict();
+const resources = tenantRuntimeResourceSchema.extend({ kind: z.literal('RESOURCES') }).strict(), projection = tenantRuntimeResourceSchema.extend({ kind: z.literal('PROJECTIONS'), expectedManifestRevision: sha256Schema, preparedAt: isoDateTimeSchema }).strict();
+const project = z.object({ kind: z.literal('PROJECTS'), projectKey: projectKeySchema, lifecycle: z.enum(['ACTIVE', 'ARCHIVED']), runtimeState: z.enum(['AVAILABLE', 'UNAVAILABLE']), projection: z.object({ requestedGeneration: count, completedGeneration: count, pendingGenerationDelta: count }).strict().nullable(), checkpointState: z.enum(['READY', 'UNAVAILABLE', 'EPOCH_MISMATCH']), directoryThroughSeq: count.nullable(), searchThroughSeq: count.nullable(), searchObservedMaxSeq: count.nullable(), searchSequenceDelta: count.nullable(), process: tenantRuntimeProcessSchema.nullable() }).strict();
+const budget = z.discriminatedUnion('state', [
+    z.object({ state: z.literal('READY'), scope: z.literal('RUNTIME_OWNER_DATA_ROOT'), windowStart: isoDateTimeSchema, windowEnd: isoDateTimeSchema, usage: z.object({ inFlight: count, workUnits: count, runtimeMs: count }).strict(), limits: tenantBudgetPolicySchema, maxWaitRounds: z.number().int().min(1).max(2048) }).strict(),
+    z.object({ state: z.enum(['NOT_CONFIGURED', 'UNAVAILABLE']), reason: z.enum(['CONFIGURATION_REQUIRED', 'TENANT_NOT_CONFIGURED', 'BINDING_MISMATCH', 'STATE_UNAVAILABLE']) }).strict(),
+]);
+export const tenantRuntimeDataSchema = z.object({ nodeId: projectKeySchema, kind: tenantRuntimeKindSchema, observedAt: isoDateTimeSchema, coverage: z.literal('OWN_TENANT_METADATA_SAMPLE'), metadataOnly: z.literal(true), pageState: z.enum(['READY', 'UNAVAILABLE']), items: z.array(z.discriminatedUnion('kind', [request, resources, projection, project])).max(20), nextAfter: cursor.nullable(), sampleCount: count.max(20), total: z.null(), budget, delivery: z.object({ headSeq: count, retainedThroughSeq: count, businessOutcome: z.literal('NOT_ASSERTED') }).strict() }).strict().superRefine((v, ctx) => { if (v.items.some(item => item.kind !== v.kind) || v.sampleCount !== v.items.length || v.pageState === 'UNAVAILABLE' && (v.items.length || v.nextAfter !== null))
+    ctx.addIssue({ code: 'custom', message: 'Metadata sample preserves kind and actual bounded row count' }); });
+export const tenantRuntimeToolSchemas = { tenant_runtime_status: tenantRuntimeInputSchema };
+export const tenantRuntimeWorkspaceToolSchemas = { ...tenantProjectWorkspaceToolSchemas, ...tenantRuntimeToolSchemas };
+export const tenantRuntimeWorkspaceDataSchemas = { ...tenantProjectWorkspaceDataSchemas, tenant_runtime_status: tenantRuntimeDataSchema };
+export function tenantRuntimeScopesForInput(name, raw) { if (name === 'tenant_runtime_status') {
+    tenantRuntimeInputSchema.parse(raw);
+    return ['knowledge.runtime.read'];
+} return tenantProjectScopesForInput(name, raw); }
+export function tenantRuntimeAuthorization(name) { return name === 'tenant_runtime_status' ? { selection: 'FIXED', scopeAlternatives: [['knowledge.runtime.read']] } : tenantProjectAuthorization(name); }
+export const tenantRuntimeStatusEnvelopeSchema = z.object({ schemaVersion: z.literal(2), tenantId: materialTenantIdSchema, tool: z.literal('tenant_runtime_status'), data: tenantRuntimeDataSchema }).strict().superRefine((value, ctx) => {
+    const { data } = value, key = tenantStorageKey(value.tenantId), mine = (ref) => parseTenantResourceRef(ref)?.storageKey === key;
+    if (data.budget.state === 'READY' && data.budget.limits.tenantId !== value.tenantId || data.items.some(item => item.kind === 'REQUESTS' ? !(new RegExp('^tenant-collection-request://' + key + '/[a-f0-9]{64}$').test(item.requestRef)) || parseTenantCollectionBatchRef(item.batchRef)?.storageKey !== key || !mine(item.raw.ref) || parseTenantResourceRef(item.raw.ref)?.resourceType !== 'evidence' : item.kind === 'PROJECTS' ? false : !mine(item.ref)))
+        ctx.addIssue({ code: 'custom', message: 'Runtime metadata retains exact Tenant scope' });
+});
+export function tenantRuntimeEnvelopeSchema(tool) { return tool === 'tenant_runtime_status' ? tenantRuntimeStatusEnvelopeSchema : z.object({ schemaVersion: z.literal(2), tenantId: materialTenantIdSchema, tool: z.literal(tool), data: tenantRuntimeWorkspaceDataSchemas[tool] }).strict(); }
+export const tenantRuntimeInputJsonSchemas = Object.fromEntries(Object.entries(tenantRuntimeWorkspaceToolSchemas).map(([name, schema]) => [name, z.toJSONSchema(schema, { target: 'draft-07' })]));
+export const tenantRuntimeOutputJsonSchemas = Object.fromEntries(Object.keys(tenantRuntimeWorkspaceToolSchemas).map(name => [name, { type: 'object', oneOf: [z.toJSONSchema(tenantRuntimeEnvelopeSchema(name), { target: 'draft-07' }), z.toJSONSchema(tenantProjectErrorSchema, { target: 'draft-07' })] }]));
+export const tenantRuntimeProviderSchema = z.object({ ...tenantProjectProviderSchema.shape, schemaVersion: z.literal(20), tools: z.array(z.string()).length(Object.keys(tenantRuntimeWorkspaceToolSchemas).length), capabilities: z.tuple([z.literal('TENANT_MANAGEMENT_V1'), z.literal('TENANT_WORKFLOW_V1'), z.literal('TENANT_CURRENTNESS_V2'), z.literal('TENANT_SOURCE_V1'), z.literal('TENANT_WORKSPACE_METADATA_V1'), z.literal('TENANT_PROJECT_CONTEXT_V1'), z.literal('TENANT_RUNTIME_STATUS_V1')]) }).strict().superRefine((value, ctx) => { if (new Set(value.tools).size !== Object.keys(tenantRuntimeWorkspaceToolSchemas).length || value.tools.some(name => !Object.hasOwn(tenantRuntimeWorkspaceToolSchemas, name)))
+    ctx.addIssue({ code: 'custom', message: 'Runtime tools must match exact version20 contract' }); });

package/dist/internal/serving-contracts/tenant-session.d.ts

@@ -0,0 +1,87 @@
+import { z } from 'zod';
+export declare const tenantSessionSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    issuer: z.ZodString;
+    resource: z.ZodString;
+    clientId: z.ZodString;
+    userId: z.ZodString;
+    tenantId: z.ZodString;
+    tenantRef: z.ZodString;
+    contextType: z.ZodLiteral<"TENANT">;
+    authorityVersion: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>;
+    tokenScopes: z.ZodArray<z.ZodString>;
+    effectiveScopes: z.ZodArray<z.ZodString>;
+    expiresAt: z.ZodString;
+    managementConfigured: z.ZodBoolean;
+    blockers: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export type TenantSession = z.infer<typeof tenantSessionSchema>;
+export declare const tenantOperationStatusInputSchema: z.ZodObject<{
+    requestId: z.ZodString;
+}, z.core.$strict>;
+export declare const tenantOperationStatusSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    tenantId: z.ZodString;
+    requestId: z.ZodString;
+    state: z.ZodEnum<{
+        NOT_FOUND: "NOT_FOUND";
+        INTENT_PERSISTED: "INTENT_PERSISTED";
+    }>;
+    operationRef: z.ZodNullable<z.ZodString>;
+    action: z.ZodNullable<z.ZodString>;
+    receivedAt: z.ZodNullable<z.ZodString>;
+    completion: z.ZodLiteral<"NOT_PROVEN">;
+}, z.core.$strict>;
+export declare const tenantClientProviderSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<26>;
+    provider: z.ZodLiteral<"knowledge-v2">;
+    revision: z.ZodString;
+    issuer: z.ZodString;
+    resource: z.ZodString;
+    authorizationServerMetadataUrl: z.ZodString;
+    tenantSessionEndpoint: z.ZodString;
+    tenantOperationStatusEndpoint: z.ZodString;
+    resourceCallEndpoint: z.ZodString;
+    resourceFileEndpoint: z.ZodString;
+    registrationModes: z.ZodArray<z.ZodEnum<{
+        PRE_REGISTERED_NATIVE: "PRE_REGISTERED_NATIVE";
+        CIMD_READ_ONLY: "CIMD_READ_ONLY";
+    }>>;
+    callbackModes: z.ZodArray<z.ZodLiteral<"NATIVE_LOOPBACK_PORT_V1">>;
+    providers: z.ZodArray<z.ZodObject<{
+        version: z.ZodNumber;
+        endpoint: z.ZodString;
+    }, z.core.$strict>>;
+    tools: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        endpoint: z.ZodString;
+        method: z.ZodDefault<z.ZodEnum<{
+            GET: "GET";
+            POST: "POST";
+        }>>;
+        inputSchema: z.ZodJSONSchema;
+        outputSchema: z.ZodJSONSchema;
+        scopeAlternatives: z.ZodArray<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    limits: z.ZodObject<{
+        requestMaxBytes: z.ZodLiteral<131072>;
+        resultMaxBytes: z.ZodLiteral<524288>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type TenantClientProvider = z.infer<typeof tenantClientProviderSchema>;
+export declare const tenantOperationStatusInputJsonSchema: z.core.ZodStandardJSONSchemaPayload<z.ZodObject<{
+    requestId: z.ZodString;
+}, z.core.$strict>>;
+export declare const tenantOperationStatusOutputJsonSchema: z.core.ZodStandardJSONSchemaPayload<z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    tenantId: z.ZodString;
+    requestId: z.ZodString;
+    state: z.ZodEnum<{
+        NOT_FOUND: "NOT_FOUND";
+        INTENT_PERSISTED: "INTENT_PERSISTED";
+    }>;
+    operationRef: z.ZodNullable<z.ZodString>;
+    action: z.ZodNullable<z.ZodString>;
+    receivedAt: z.ZodNullable<z.ZodString>;
+    completion: z.ZodLiteral<"NOT_PROVEN">;
+}, z.core.$strict>>;

package/dist/internal/serving-contracts/tenant-session.js

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+const endpoint = z.string().url(), id = z.string().min(1).max(512), scopes = z.array(z.string().min(1).max(100)).max(32);
+export const tenantSessionSchema = z.object({ schemaVersion: z.literal(1), issuer: endpoint, resource: endpoint, clientId: id, userId: id, tenantId: id, tenantRef: z.string().startsWith('knowledge-tenant://'), contextType: z.literal('TENANT'), authorityVersion: z.union([z.literal(1), z.literal(2)]), tokenScopes: scopes, effectiveScopes: scopes, expiresAt: z.string().datetime(), managementConfigured: z.boolean(), blockers: z.array(z.string()).max(16) }).strict();
+export const tenantOperationStatusInputSchema = z.object({ requestId: z.string().min(1).max(128).regex(/^[A-Za-z0-9][A-Za-z0-9._:-]*$/) }).strict();
+export const tenantOperationStatusSchema = z.object({ schemaVersion: z.literal(1), tenantId: id, requestId: z.string(), state: z.enum(['NOT_FOUND', 'INTENT_PERSISTED']), operationRef: z.string().nullable(), action: z.string().nullable(), receivedAt: z.string().datetime().nullable(), completion: z.literal('NOT_PROVEN') }).strict();
+export const tenantClientProviderSchema = z.object({ schemaVersion: z.literal(26), provider: z.literal('knowledge-v2'), revision: z.string(), issuer: endpoint, resource: endpoint, authorizationServerMetadataUrl: endpoint, tenantSessionEndpoint: endpoint, tenantOperationStatusEndpoint: endpoint, resourceCallEndpoint: endpoint, resourceFileEndpoint: endpoint, registrationModes: z.array(z.enum(['PRE_REGISTERED_NATIVE', 'CIMD_READ_ONLY'])).max(2), callbackModes: z.array(z.literal('NATIVE_LOOPBACK_PORT_V1')).max(1), providers: z.array(z.object({ version: z.number().int().min(16).max(26), endpoint }).strict()).max(11), tools: z.array(z.object({ name: z.string(), endpoint, method: z.enum(['GET', 'POST']).default('POST'), inputSchema: z.json(), outputSchema: z.json(), scopeAlternatives: z.array(scopes).max(8) }).strict()).max(100), limits: z.object({ requestMaxBytes: z.literal(131072), resultMaxBytes: z.literal(524288) }).strict() }).strict();
+export const tenantOperationStatusInputJsonSchema = z.toJSONSchema(tenantOperationStatusInputSchema, { target: 'draft-07' });
+export const tenantOperationStatusOutputJsonSchema = z.toJSONSchema(tenantOperationStatusSchema, { target: 'draft-07' });