@nsp-labs/agnostic-sdk 1.0.4 → 1.4.0

package/src/index.d.ts

@@ -1,4 +1,5 @@
-export { AgnosticRuntime, RuntimeAppAuthNamespace, RuntimeContextNamespace, RuntimeDataNamespace, RuntimeDataRecordsClient, RuntimeDataTableClient, RuntimeDataViewClient, RuntimeDataViewTableClient, RuntimeWorkflowRunsNamespace, RuntimeWorkflowsNamespace, createAgnosticRuntime, } from './lib/runtime-client';
+export { AgnosticRuntime, RuntimeAppAuthNamespace, RuntimeContextNamespace, RuntimeDataNamespace, RuntimeDataRecordsClient, RuntimeDataTableClient, RuntimeDataViewClient, RuntimeDataViewTableClient, RuntimeAnonymousUploadsClient, RuntimeStorageBucketClient, RuntimeStorageNamespace, RuntimeWorkflowRunsNamespace, RuntimeWorkflowsNamespace, createAgnosticRuntime, } from './lib/runtime-client';
 export { normalizeApiUrl, resolveRuntimeContext } from './lib/context';
 export { AgnosticRuntimeError } from './lib/errors';
-export type { AgnosticRuntimeConfig, ResolvedRuntimeContext, RuntimeActorMetadata, RuntimeActorType, RuntimeAppAuthActor, RuntimeAppAuthCachePolicy, RuntimeAppAuthRequestLike, RuntimeAppAuthSession, RuntimeAppAuthSessionClaims, RuntimeAppAuthUserClaims, RuntimeAppAuthUserResult, RuntimeCreateRecordInput, RuntimeDataField, RuntimeDataViewState, RuntimeIdentityContext, RuntimeListRecordsOptions, RuntimeListWindowOptions, RuntimeRecord, RuntimeRecordMutation, RuntimeRecordsList, RuntimeRequestOptions, RuntimeRowData, RuntimeRowValue, RuntimeTableWindow, RuntimeUpdateRecordInput, RuntimeWorkflowRun, RuntimeWorkflowStepRun, RuntimeWorkflowWaitOptions, WorkflowRunStatus, } from './lib/types';
+export { AGNOSTIC_RUNTIME_SDK_MANIFEST, type AgnosticRuntimeSdkManifest, } from './lib/manifest';
+export type { AgnosticRuntimeConfig, RuntimeAggregateMetric, RuntimeAggregateOperation, RuntimeAggregateOrderBy, RuntimeAggregateRecordsInput, RuntimeAggregateRecordsResult, RuntimeAggregateRow, ResolvedRuntimeContext, RuntimeActorMetadata, RuntimeActorType, RuntimeAnonymousClaimFileHandle, RuntimeAnonymousClaimInput, RuntimeAnonymousClaimResult, RuntimeAppAuthActor, RuntimeAppAuthCachePolicy, RuntimeAppAuthRequestLike, RuntimeAppAuthSession, RuntimeAppAuthSessionClaims, RuntimeAppAuthUserClaims, RuntimeAppAuthUserResult, RuntimeCreateRecordInput, RuntimeCreateFileUploadInput, RuntimeDataField, RuntimeDataViewState, RuntimeIdentityContext, RuntimeFileAccessMode, RuntimeFileDownloadUrl, RuntimeFileObject, RuntimeFileObjectStatus, RuntimeFileUploadCompletion, RuntimeFileUploadGrant, RuntimeListRecordsOptions, RuntimeListWindowOptions, RuntimeRecord, RuntimeRecordMutation, RuntimeRecordsList, RuntimeRequestOptions, RuntimeRowData, RuntimeRowValue, RuntimeTableWindow, RuntimeUpdateRecordInput, RuntimeWorkflowRun, RuntimeWorkflowStepRun, RuntimeWorkflowWaitOptions, WorkflowRunStatus, } from './lib/types';

package/src/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AgnosticRuntimeError = exports.resolveRuntimeContext = exports.normalizeApiUrl = exports.createAgnosticRuntime = exports.RuntimeWorkflowsNamespace = exports.RuntimeWorkflowRunsNamespace = exports.RuntimeDataViewTableClient = exports.RuntimeDataViewClient = exports.RuntimeDataTableClient = exports.RuntimeDataRecordsClient = exports.RuntimeDataNamespace = exports.RuntimeContextNamespace = exports.RuntimeAppAuthNamespace = exports.AgnosticRuntime = void 0;
+exports.AGNOSTIC_RUNTIME_SDK_MANIFEST = exports.AgnosticRuntimeError = exports.resolveRuntimeContext = exports.normalizeApiUrl = exports.createAgnosticRuntime = exports.RuntimeWorkflowsNamespace = exports.RuntimeWorkflowRunsNamespace = exports.RuntimeStorageNamespace = exports.RuntimeStorageBucketClient = exports.RuntimeAnonymousUploadsClient = exports.RuntimeDataViewTableClient = exports.RuntimeDataViewClient = exports.RuntimeDataTableClient = exports.RuntimeDataRecordsClient = exports.RuntimeDataNamespace = exports.RuntimeContextNamespace = exports.RuntimeAppAuthNamespace = exports.AgnosticRuntime = void 0;
 var runtime_client_1 = require("./lib/runtime-client");
 Object.defineProperty(exports, "AgnosticRuntime", { enumerable: true, get: function () { return runtime_client_1.AgnosticRuntime; } });
 Object.defineProperty(exports, "RuntimeAppAuthNamespace", { enumerable: true, get: function () { return runtime_client_1.RuntimeAppAuthNamespace; } });
@@ -10,6 +10,9 @@ Object.defineProperty(exports, "RuntimeDataRecordsClient", { enumerable: true, g
 Object.defineProperty(exports, "RuntimeDataTableClient", { enumerable: true, get: function () { return runtime_client_1.RuntimeDataTableClient; } });
 Object.defineProperty(exports, "RuntimeDataViewClient", { enumerable: true, get: function () { return runtime_client_1.RuntimeDataViewClient; } });
 Object.defineProperty(exports, "RuntimeDataViewTableClient", { enumerable: true, get: function () { return runtime_client_1.RuntimeDataViewTableClient; } });
+Object.defineProperty(exports, "RuntimeAnonymousUploadsClient", { enumerable: true, get: function () { return runtime_client_1.RuntimeAnonymousUploadsClient; } });
+Object.defineProperty(exports, "RuntimeStorageBucketClient", { enumerable: true, get: function () { return runtime_client_1.RuntimeStorageBucketClient; } });
+Object.defineProperty(exports, "RuntimeStorageNamespace", { enumerable: true, get: function () { return runtime_client_1.RuntimeStorageNamespace; } });
 Object.defineProperty(exports, "RuntimeWorkflowRunsNamespace", { enumerable: true, get: function () { return runtime_client_1.RuntimeWorkflowRunsNamespace; } });
 Object.defineProperty(exports, "RuntimeWorkflowsNamespace", { enumerable: true, get: function () { return runtime_client_1.RuntimeWorkflowsNamespace; } });
 Object.defineProperty(exports, "createAgnosticRuntime", { enumerable: true, get: function () { return runtime_client_1.createAgnosticRuntime; } });
@@ -18,4 +21,6 @@ Object.defineProperty(exports, "normalizeApiUrl", { enumerable: true, get: funct
 Object.defineProperty(exports, "resolveRuntimeContext", { enumerable: true, get: function () { return context_1.resolveRuntimeContext; } });
 var errors_1 = require("./lib/errors");
 Object.defineProperty(exports, "AgnosticRuntimeError", { enumerable: true, get: function () { return errors_1.AgnosticRuntimeError; } });
+var manifest_1 = require("./lib/manifest");
+Object.defineProperty(exports, "AGNOSTIC_RUNTIME_SDK_MANIFEST", { enumerable: true, get: function () { return manifest_1.AGNOSTIC_RUNTIME_SDK_MANIFEST; } });
 //# sourceMappingURL=index.js.map

package/src/lib/manifest.d.ts

@@ -0,0 +1,41 @@
+export declare const AGNOSTIC_RUNTIME_SDK_MANIFEST: Readonly<{
+    readonly promptSync: Readonly<{
+        source: "sdk_exported_manifest";
+        strategy: "inject_on_every_agent_codegen_context";
+        surfaceFingerprint: string;
+        driftPolicy: "fail_ci_on_public_surface_or_package_version_mismatch";
+        memorizedSdkKnowledgeAllowed: false;
+    }>;
+    readonly schema: "agnostic_runtime_sdk_manifest.v1";
+    readonly package: Readonly<{
+        name: "@nsp-labs/agnostic-sdk";
+        version: "1.4.0";
+        factory: "createAgnosticRuntime";
+        runtime: "server_only";
+    }>;
+    readonly context: Readonly<{
+        automatic: true;
+        environmentVariables: readonly string[];
+        secretEnvironmentVariables: readonly string[];
+    }>;
+    readonly rootMembers: readonly [...("data" | "auth" | "context" | "storage" | "workflows" | "workflowRuns")[], "getRuntimeContext"];
+    readonly clientMethods: readonly ["getRuntimeContext"];
+    readonly namespaces: Readonly<{
+        auth: readonly ("requireSession" | "getSession" | "requireScopes" | "getUser")[];
+        context: readonly "get"[];
+        data: readonly ("table(name).records.delete" | "table(name).records.list" | "table(name).records.aggregate" | "table(name).records.create" | "table(name).records.update" | "view(id).table.window")[];
+        storage: readonly ("bucket(name).get" | "bucket(name).delete" | "bucket(name).createUpload" | "bucket(name).completeUpload" | "bucket(name).createDownloadUrl" | "bucket(name).anonymousUploads.claim")[];
+        workflows: readonly ("start" | "getRun")[];
+        workflowRuns: readonly ("get" | "wait" | "listSteps")[];
+    }>;
+    readonly unsupportedNamespaces: readonly string[];
+    readonly boundaries: Readonly<{
+        controlPlaneProvisioning: "agent_product_tools";
+        runtimeAccess: "server_sdk";
+        browserAccess: "public_api_or_app_auth_session";
+        appAuthSelfService: "public_api_via_project_backend_bff";
+        browserPackageImportAllowed: false;
+        browserRuntimeTokenAllowed: false;
+    }>;
+}>;
+export type AgnosticRuntimeSdkManifest = typeof AGNOSTIC_RUNTIME_SDK_MANIFEST;

package/src/lib/manifest.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AGNOSTIC_RUNTIME_SDK_MANIFEST = void 0;
+const node_crypto_1 = require("node:crypto");
+const AUTH_KEYS_LITERAL = [
+    'requireSession',
+    'getSession',
+    'requireScopes',
+    'getUser',
+];
+const AUTH_KEYS = AUTH_KEYS_LITERAL;
+const CONTEXT_KEYS_LITERAL = ['get'];
+const CONTEXT_KEYS = CONTEXT_KEYS_LITERAL;
+const DATA_NAMESPACE_KEYS_LITERAL = ['table', 'view'];
+const DATA_NAMESPACE_KEYS = DATA_NAMESPACE_KEYS_LITERAL;
+const DATA_TABLE_KEYS_LITERAL = ['records'];
+const DATA_TABLE_KEYS = DATA_TABLE_KEYS_LITERAL;
+const DATA_RECORD_KEYS_LITERAL = [
+    'list',
+    'aggregate',
+    'create',
+    'update',
+    'delete',
+];
+const DATA_RECORD_KEYS = DATA_RECORD_KEYS_LITERAL;
+const DATA_VIEW_KEYS_LITERAL = ['table'];
+const DATA_VIEW_KEYS = DATA_VIEW_KEYS_LITERAL;
+const DATA_VIEW_TABLE_KEYS_LITERAL = ['window'];
+const DATA_VIEW_TABLE_KEYS = DATA_VIEW_TABLE_KEYS_LITERAL;
+const STORAGE_NAMESPACE_KEYS_LITERAL = ['bucket'];
+const STORAGE_NAMESPACE_KEYS = STORAGE_NAMESPACE_KEYS_LITERAL;
+const STORAGE_BUCKET_KEYS_LITERAL = [
+    'anonymousUploads',
+    'createUpload',
+    'completeUpload',
+    'get',
+    'createDownloadUrl',
+    'delete',
+];
+const STORAGE_BUCKET_KEYS = STORAGE_BUCKET_KEYS_LITERAL;
+const ANONYMOUS_UPLOAD_KEYS_LITERAL = ['claim'];
+const ANONYMOUS_UPLOAD_KEYS = ANONYMOUS_UPLOAD_KEYS_LITERAL;
+const WORKFLOW_KEYS_LITERAL = ['start', 'getRun'];
+const WORKFLOW_KEYS = WORKFLOW_KEYS_LITERAL;
+const WORKFLOW_RUN_KEYS_LITERAL = ['get', 'wait', 'listSteps'];
+const WORKFLOW_RUN_KEYS = WORKFLOW_RUN_KEYS_LITERAL;
+const CLIENT_METHODS = Object.freeze(['getRuntimeContext']);
+const NAMESPACES = Object.freeze({
+    auth: Object.freeze([...AUTH_KEYS]),
+    context: Object.freeze([...CONTEXT_KEYS]),
+    data: Object.freeze([
+        ...DATA_RECORD_KEYS.map((method) => `${DATA_NAMESPACE_KEYS[0]}(name).${DATA_TABLE_KEYS[0]}.${method}`),
+        ...DATA_VIEW_TABLE_KEYS.map((method) => `${DATA_NAMESPACE_KEYS[1]}(id).${DATA_VIEW_KEYS[0]}.${method}`),
+    ]),
+    storage: Object.freeze([
+        ...STORAGE_BUCKET_KEYS.filter((method) => method !== 'anonymousUploads').map((method) => `${STORAGE_NAMESPACE_KEYS[0]}(name).${method}`),
+        ...ANONYMOUS_UPLOAD_KEYS.map((method) => `${STORAGE_NAMESPACE_KEYS[0]}(name).${STORAGE_BUCKET_KEYS[0]}.${method}`),
+    ]),
+    workflows: Object.freeze([...WORKFLOW_KEYS]),
+    workflowRuns: Object.freeze([...WORKFLOW_RUN_KEYS]),
+});
+const ROOT_MEMBERS_LITERAL = Object.freeze([
+    ...Object.keys(NAMESPACES),
+    ...CLIENT_METHODS,
+]);
+const ROOT_MEMBERS = ROOT_MEMBERS_LITERAL;
+const MANIFEST_CONTRACT = Object.freeze({
+    schema: 'agnostic_runtime_sdk_manifest.v1',
+    package: Object.freeze({
+        name: '@nsp-labs/agnostic-sdk',
+        version: '1.4.0',
+        factory: 'createAgnosticRuntime',
+        runtime: 'server_only',
+    }),
+    context: Object.freeze({
+        automatic: true,
+        environmentVariables: Object.freeze([
+            'AGNOSTIC_API_URL',
+            'AGNOSTIC_PROJECT_ID',
+            'AGNOSTIC_ENVIRONMENT',
+            'AGNOSTIC_RUNTIME_TOKEN',
+        ]),
+        secretEnvironmentVariables: Object.freeze(['AGNOSTIC_RUNTIME_TOKEN']),
+    }),
+    rootMembers: ROOT_MEMBERS,
+    clientMethods: CLIENT_METHODS,
+    namespaces: NAMESPACES,
+    unsupportedNamespaces: Object.freeze([
+        'ai',
+        'events',
+        'gateway',
+        'jobs',
+        'realtime',
+    ]),
+    boundaries: Object.freeze({
+        controlPlaneProvisioning: 'agent_product_tools',
+        runtimeAccess: 'server_sdk',
+        browserAccess: 'public_api_or_app_auth_session',
+        appAuthSelfService: 'public_api_via_project_backend_bff',
+        browserPackageImportAllowed: false,
+        browserRuntimeTokenAllowed: false,
+    }),
+});
+const surfaceFingerprint = `sha256:${(0, node_crypto_1.createHash)('sha256')
+    .update(JSON.stringify(MANIFEST_CONTRACT))
+    .digest('hex')}`;
+exports.AGNOSTIC_RUNTIME_SDK_MANIFEST = Object.freeze({
+    ...MANIFEST_CONTRACT,
+    promptSync: Object.freeze({
+        source: 'sdk_exported_manifest',
+        strategy: 'inject_on_every_agent_codegen_context',
+        surfaceFingerprint,
+        driftPolicy: 'fail_ci_on_public_surface_or_package_version_mismatch',
+        memorizedSdkKnowledgeAllowed: false,
+    }),
+});
+//# sourceMappingURL=manifest.js.map

package/src/lib/runtime-client.d.ts

@@ -1,9 +1,10 @@
 import { type RuntimeOpenApiClient } from './http-client';
-import type { AgnosticRuntimeConfig, ResolvedRuntimeContext, RuntimeAppAuthRequestLike, RuntimeAppAuthSession, RuntimeAppAuthUserResult, RuntimeCreateRecordInput, RuntimeIdentityContext, RuntimeListRecordsOptions, RuntimeListWindowOptions, RuntimeRecordMutation, RuntimeRecordsList, RuntimeRequestOptions, RuntimeRowData, RuntimeTableWindow, RuntimeUpdateRecordInput, RuntimeWorkflowRun, RuntimeWorkflowStepRun, RuntimeWorkflowWaitOptions } from './types';
+import type { AgnosticRuntimeConfig, ResolvedRuntimeContext, RuntimeAppAuthRequestLike, RuntimeAppAuthSession, RuntimeAppAuthUserResult, RuntimeAnonymousClaimInput, RuntimeAnonymousClaimResult, RuntimeAggregateRecordsInput, RuntimeAggregateRecordsResult, RuntimeCreateFileUploadInput, RuntimeCreateRecordInput, RuntimeIdentityContext, RuntimeFileDownloadUrl, RuntimeFileObject, RuntimeFileUploadCompletion, RuntimeFileUploadGrant, RuntimeListRecordsOptions, RuntimeListWindowOptions, RuntimeRecordMutation, RuntimeRecordsList, RuntimeRequestOptions, RuntimeRowData, RuntimeTableWindow, RuntimeUpdateRecordInput, RuntimeWorkflowRun, RuntimeWorkflowStepRun, RuntimeWorkflowWaitOptions } from './types';
 export declare class AgnosticRuntime {
     readonly auth: RuntimeAppAuthNamespace;
     readonly context: RuntimeContextNamespace;
     readonly data: RuntimeDataNamespace;
+    readonly storage: RuntimeStorageNamespace;
     readonly workflows: RuntimeWorkflowsNamespace;
     readonly workflowRuns: RuntimeWorkflowRunsNamespace;
     private readonly openapi;
@@ -15,6 +16,8 @@ export declare class RuntimeAppAuthNamespace {
     private readonly openapi;
     constructor(openapi: RuntimeOpenApiClient);
     requireSession(request: RuntimeAppAuthRequestLike | string, options?: RuntimeRequestOptions): Promise<RuntimeAppAuthSession>;
+    getSession(request: RuntimeAppAuthRequestLike | string, options?: RuntimeRequestOptions): Promise<RuntimeAppAuthSession | null>;
+    requireScopes(request: RuntimeAppAuthRequestLike | string, scopes: readonly string[], options?: RuntimeRequestOptions): Promise<RuntimeAppAuthSession>;
     getUser(userId: string, options?: RuntimeRequestOptions): Promise<RuntimeAppAuthUserResult>;
 }
 export declare function createAgnosticRuntime(config?: AgnosticRuntimeConfig): AgnosticRuntime;
@@ -29,6 +32,28 @@ export declare class RuntimeDataNamespace {
     table(tableName: string): RuntimeDataTableClient;
     view(viewId: string): RuntimeDataViewClient;
 }
+export declare class RuntimeStorageNamespace {
+    private readonly openapi;
+    constructor(openapi: RuntimeOpenApiClient);
+    bucket(bucketIdOrSlug: string): RuntimeStorageBucketClient;
+}
+export declare class RuntimeStorageBucketClient {
+    private readonly openapi;
+    private readonly bucketIdOrSlug;
+    readonly anonymousUploads: RuntimeAnonymousUploadsClient;
+    constructor(openapi: RuntimeOpenApiClient, bucketIdOrSlug: string);
+    createUpload(input: RuntimeCreateFileUploadInput, options?: RuntimeRequestOptions): Promise<RuntimeFileUploadGrant>;
+    completeUpload(uploadId: string, options?: RuntimeRequestOptions): Promise<RuntimeFileUploadCompletion>;
+    get(fileId: string, options?: RuntimeRequestOptions): Promise<RuntimeFileObject>;
+    createDownloadUrl(fileId: string, options?: RuntimeRequestOptions): Promise<RuntimeFileDownloadUrl>;
+    delete(fileId: string, options?: RuntimeRequestOptions): Promise<void>;
+}
+export declare class RuntimeAnonymousUploadsClient {
+    private readonly openapi;
+    private readonly bucketIdOrSlug;
+    constructor(openapi: RuntimeOpenApiClient, bucketIdOrSlug: string);
+    claim(input: RuntimeAnonymousClaimInput, options?: RuntimeRequestOptions): Promise<RuntimeAnonymousClaimResult>;
+}
 export declare class RuntimeDataTableClient {
     private readonly tableName;
     readonly records: RuntimeDataRecordsClient;
@@ -39,6 +64,7 @@ export declare class RuntimeDataRecordsClient {
     private readonly tableName;
     constructor(openapi: RuntimeOpenApiClient, tableName: string);
     list(query?: RuntimeListRecordsOptions, options?: RuntimeRequestOptions): Promise<RuntimeRecordsList>;
+    aggregate(input: RuntimeAggregateRecordsInput, options?: RuntimeRequestOptions): Promise<RuntimeAggregateRecordsResult>;
     create(input: RuntimeCreateRecordInput | RuntimeRowData, options?: RuntimeRequestOptions): Promise<RuntimeRecordMutation>;
     update(recordId: string, input: RuntimeUpdateRecordInput | RuntimeRowData, options?: RuntimeRequestOptions): Promise<RuntimeRecordMutation>;
     delete(recordId: string, options?: RuntimeRequestOptions): Promise<RuntimeRecordMutation>;

package/src/lib/runtime-client.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RuntimeWorkflowRunsNamespace = exports.RuntimeWorkflowsNamespace = exports.RuntimeDataViewTableClient = exports.RuntimeDataViewClient = exports.RuntimeDataRecordsClient = exports.RuntimeDataTableClient = exports.RuntimeDataNamespace = exports.RuntimeContextNamespace = exports.RuntimeAppAuthNamespace = exports.AgnosticRuntime = void 0;
+exports.RuntimeWorkflowRunsNamespace = exports.RuntimeWorkflowsNamespace = exports.RuntimeDataViewTableClient = exports.RuntimeDataViewClient = exports.RuntimeDataRecordsClient = exports.RuntimeDataTableClient = exports.RuntimeAnonymousUploadsClient = exports.RuntimeStorageBucketClient = exports.RuntimeStorageNamespace = exports.RuntimeDataNamespace = exports.RuntimeContextNamespace = exports.RuntimeAppAuthNamespace = exports.AgnosticRuntime = void 0;
 exports.createAgnosticRuntime = createAgnosticRuntime;
 const http_client_1 = require("./http-client");
 const context_1 = require("./context");
@@ -9,8 +9,14 @@ const APP_AUTH_VERIFY_SESSION_PATH = '/api/v1/runtime/app-auth/session/verify';
 const APP_AUTH_USER_PATH = '/api/v1/runtime/app-auth/users/{userId}';
 const AUTH_CONTEXT_PATH = '/api/v1/runtime/auth/context';
 const DATA_RECORDS_PATH = '/api/v1/runtime/data/tables/{tableName}/records';
+const DATA_AGGREGATE_PATH = '/api/v1/runtime/data/tables/{tableName}/records/aggregate';
 const DATA_RECORD_PATH = '/api/v1/runtime/data/tables/{tableName}/records/{recordId}';
 const DATA_VIEW_WINDOW_PATH = '/api/v1/runtime/data/views/{viewId}/table/window';
+const FILES_ANONYMOUS_CLAIM_PATH = '/api/v1/runtime/files/buckets/{bucketRef}/anonymous-upload-sessions/claim';
+const FILES_UPLOADS_PATH = '/api/v1/runtime/files/buckets/{bucketRef}/uploads';
+const FILES_UPLOAD_COMPLETE_PATH = '/api/v1/runtime/files/buckets/{bucketRef}/uploads/{uploadId}/complete';
+const FILES_OBJECT_PATH = '/api/v1/runtime/files/buckets/{bucketRef}/objects/{fileId}';
+const FILES_DOWNLOAD_PATH = '/api/v1/runtime/files/buckets/{bucketRef}/objects/{fileId}/download';
 const WORKFLOWS_START_PATH = '/api/v1/runtime/workflows/{workflowSlug}/runs';
 const WORKFLOW_RUN_PATH = '/api/v1/runtime/workflow-runs/{runId}';
 const WORKFLOW_RUN_STEPS_PATH = '/api/v1/runtime/workflow-runs/{runId}/steps';
@@ -32,6 +38,7 @@ class AgnosticRuntime {
         this.auth = new RuntimeAppAuthNamespace(this.openapi);
         this.context = new RuntimeContextNamespace(this.openapi);
         this.data = new RuntimeDataNamespace(this.openapi);
+        this.storage = new RuntimeStorageNamespace(this.openapi);
         this.workflowRuns = new RuntimeWorkflowRunsNamespace(this.openapi);
         this.workflows = new RuntimeWorkflowsNamespace(this.openapi, this.workflowRuns);
     }
@@ -58,11 +65,35 @@ class RuntimeAppAuthNamespace {
                 },
             });
         }
-        const result = await this.openapi.POST(APP_AUTH_VERIFY_SESSION_PATH, {
-            body: { sessionToken },
-            headers: (0, http_client_1.runtimeRequestHeaders)(options),
-        });
-        return (0, http_client_1.unwrapRuntimeResult)(result, 'Failed to verify App Auth session');
+        return verifyAppAuthSession(this.openapi, sessionToken, options);
+    }
+    async getSession(request, options) {
+        const sessionToken = typeof request === 'string'
+            ? normalizeSessionToken(request)
+            : extractAppSessionToken(request);
+        if (!sessionToken) {
+            return null;
+        }
+        return verifyAppAuthSession(this.openapi, sessionToken, options);
+    }
+    async requireScopes(request, scopes, options) {
+        const session = await this.requireSession(request, options);
+        const requiredScopes = Array.from(new Set(scopes.map((scope) => scope.trim()).filter(Boolean)));
+        const availableScopes = new Set(session.user.scopes);
+        const missingScopes = requiredScopes.filter((scope) => !availableScopes.has(scope));
+        if (missingScopes.length > 0) {
+            throw new errors_1.AgnosticRuntimeError({
+                status: 403,
+                code: 'app_auth_scope_missing',
+                message: 'App user is missing a required scope',
+                details: {
+                    availableScopes: session.user.scopes,
+                    missingScopes,
+                    requiredScopes,
+                },
+            });
+        }
+        return session;
     }
     async getUser(userId, options) {
         const result = await this.openapi.GET(APP_AUTH_USER_PATH, {
@@ -78,6 +109,13 @@ exports.RuntimeAppAuthNamespace = RuntimeAppAuthNamespace;
 function createAgnosticRuntime(config = {}) {
     return new AgnosticRuntime(config);
 }
+async function verifyAppAuthSession(openapi, sessionToken, options) {
+    const result = await openapi.POST(APP_AUTH_VERIFY_SESSION_PATH, {
+        body: { sessionToken },
+        headers: (0, http_client_1.runtimeRequestHeaders)(options),
+    });
+    return (0, http_client_1.unwrapRuntimeResult)(result, 'Failed to verify App Auth session');
+}
 class RuntimeContextNamespace {
     constructor(openapi) {
         this.openapi = openapi;
@@ -102,6 +140,76 @@ class RuntimeDataNamespace {
     }
 }
 exports.RuntimeDataNamespace = RuntimeDataNamespace;
+class RuntimeStorageNamespace {
+    constructor(openapi) {
+        this.openapi = openapi;
+    }
+    bucket(bucketIdOrSlug) {
+        return new RuntimeStorageBucketClient(this.openapi, bucketIdOrSlug);
+    }
+}
+exports.RuntimeStorageNamespace = RuntimeStorageNamespace;
+class RuntimeStorageBucketClient {
+    constructor(openapi, bucketIdOrSlug) {
+        this.openapi = openapi;
+        this.bucketIdOrSlug = bucketIdOrSlug;
+        this.anonymousUploads = new RuntimeAnonymousUploadsClient(openapi, bucketIdOrSlug);
+    }
+    async createUpload(input, options) {
+        const result = await this.openapi.POST(FILES_UPLOADS_PATH, {
+            body: input,
+            headers: (0, http_client_1.runtimeRequestHeaders)(options),
+            params: { path: { bucketRef: this.bucketIdOrSlug } },
+        });
+        return (0, http_client_1.unwrapRuntimeResult)(result, 'Failed to create file upload');
+    }
+    async completeUpload(uploadId, options) {
+        const result = await this.openapi.POST(FILES_UPLOAD_COMPLETE_PATH, {
+            headers: (0, http_client_1.runtimeRequestHeaders)(options),
+            params: { path: { bucketRef: this.bucketIdOrSlug, uploadId } },
+        });
+        return (0, http_client_1.unwrapRuntimeResult)(result, 'Failed to complete file upload');
+    }
+    async get(fileId, options) {
+        const result = await this.openapi.GET(FILES_OBJECT_PATH, {
+            headers: (0, http_client_1.runtimeRequestHeaders)(options),
+            params: { path: { bucketRef: this.bucketIdOrSlug, fileId } },
+        });
+        return (0, http_client_1.unwrapRuntimeResult)(result, 'Failed to load file status');
+    }
+    async createDownloadUrl(fileId, options) {
+        const result = await this.openapi.POST(FILES_DOWNLOAD_PATH, {
+            headers: (0, http_client_1.runtimeRequestHeaders)(options),
+            params: { path: { bucketRef: this.bucketIdOrSlug, fileId } },
+        });
+        return (0, http_client_1.unwrapRuntimeResult)(result, 'Failed to create file download URL');
+    }
+    async delete(fileId, options) {
+        const result = await this.openapi.DELETE(FILES_OBJECT_PATH, {
+            headers: (0, http_client_1.runtimeRequestHeaders)(options),
+            params: { path: { bucketRef: this.bucketIdOrSlug, fileId } },
+        });
+        return (0, http_client_1.unwrapRuntimeResult)(result, 'Failed to delete file');
+    }
+}
+exports.RuntimeStorageBucketClient = RuntimeStorageBucketClient;
+class RuntimeAnonymousUploadsClient {
+    constructor(openapi, bucketIdOrSlug) {
+        this.openapi = openapi;
+        this.bucketIdOrSlug = bucketIdOrSlug;
+    }
+    async claim(input, options) {
+        const result = await this.openapi.POST(FILES_ANONYMOUS_CLAIM_PATH, {
+            body: input,
+            headers: (0, http_client_1.runtimeRequestHeaders)(options),
+            params: {
+                path: { bucketRef: this.bucketIdOrSlug },
+            },
+        });
+        return (0, http_client_1.unwrapRuntimeResult)(result, 'Failed to claim anonymous uploads');
+    }
+}
+exports.RuntimeAnonymousUploadsClient = RuntimeAnonymousUploadsClient;
 class RuntimeDataTableClient {
     constructor(openapi, tableName) {
         this.tableName = tableName;
@@ -124,6 +232,16 @@ class RuntimeDataRecordsClient {
         });
         return (0, http_client_1.unwrapRuntimeResult)(result, 'Failed to list data records');
     }
+    async aggregate(input, options) {
+        const result = await this.openapi.POST(DATA_AGGREGATE_PATH, {
+            body: input,
+            headers: (0, http_client_1.runtimeRequestHeaders)(options),
+            params: {
+                path: { tableName: this.tableName },
+            },
+        });
+        return (0, http_client_1.unwrapRuntimeResult)(result, 'Failed to aggregate data records');
+    }
     async create(input, options) {
         const result = await this.openapi.POST(DATA_RECORDS_PATH, {
             body: normalizeCreateRecordInput(input),

package/src/lib/types.d.ts

@@ -39,6 +39,72 @@ export interface RuntimeRequestOptions {
     actor?: RuntimeActorMetadata | null;
     headers?: Record<string, string>;
 }
+export interface RuntimeAnonymousClaimInput {
+    token: string;
+    externalRef: string;
+    idempotencyKey: string;
+}
+export interface RuntimeAnonymousClaimFileHandle {
+    fileId: string;
+    status: 'ready' | 'processing';
+}
+export interface RuntimeAnonymousClaimResult {
+    sessionId: string;
+    bucketId: string;
+    externalRef: string;
+    claimedAt: string;
+    files: RuntimeAnonymousClaimFileHandle[];
+}
+export type RuntimeFileAccessMode = 'private' | 'authenticated' | 'team' | 'public';
+export type RuntimeFileObjectStatus = 'pending_upload' | 'uploaded' | 'scanning' | 'ready' | 'verified_unclaimed' | 'claimed_ready' | 'deleting' | 'deleted' | 'rejected' | 'quarantined' | 'expired';
+export interface RuntimeCreateFileUploadInput {
+    fileName: string;
+    contentType: string;
+    size: number;
+    checksumSha256: string;
+    access?: RuntimeFileAccessMode;
+    idempotencyKey: string;
+}
+export interface RuntimeFileUploadGrant {
+    id: string;
+    fileId: string;
+    bucketId: string;
+    status: 'issued' | 'uploaded' | 'verifying' | 'completed' | 'rejected' | 'expired';
+    expectedSizeBytes: number;
+    expiresAt: string;
+    completedAt: string | null;
+    uploadUrl: string;
+    uploadUrlExpiresAt: string;
+    requiredHeaders: Readonly<Record<string, string>>;
+}
+export interface RuntimeFileObject {
+    id: string;
+    bucketId: string;
+    projectId: string;
+    environment: string;
+    originalName: string;
+    detectedMime: string | null;
+    sizeBytes: number | null;
+    checksumSha256: string | null;
+    status: RuntimeFileObjectStatus;
+    access: RuntimeFileAccessMode;
+    readyAt: string | null;
+    deletedAt: string | null;
+    billableUntil: string | null;
+    physicalDeleteDueAt: string | null;
+    physicalDeletedAt: string | null;
+    expiresAt: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface RuntimeFileUploadCompletion {
+    upload: Omit<RuntimeFileUploadGrant, 'uploadUrl' | 'uploadUrlExpiresAt' | 'requiredHeaders'>;
+    file: RuntimeFileObject;
+}
+export interface RuntimeFileDownloadUrl {
+    url: string;
+    expiresAt: string;
+}
 export type RuntimeHeaderValue = string | string[] | undefined;
 export interface RuntimeAppAuthRequestLike {
     headers?: Headers | Record<string, RuntimeHeaderValue> | {
@@ -92,6 +158,33 @@ export interface RuntimeListRecordsOptions {
     q?: string;
     sort?: string;
 }
+export type RuntimeAggregateOperation = 'count' | 'sum' | 'avg' | 'min' | 'max';
+export interface RuntimeAggregateMetric {
+    operation: RuntimeAggregateOperation;
+    field?: string;
+    as: string;
+}
+export interface RuntimeAggregateOrderBy {
+    by: string;
+    direction: 'asc' | 'desc';
+}
+export interface RuntimeAggregateRecordsInput {
+    filter?: Record<string, unknown>;
+    q?: string;
+    groupBy?: string[];
+    metrics: RuntimeAggregateMetric[];
+    orderBy?: RuntimeAggregateOrderBy[];
+    limit?: number;
+}
+export interface RuntimeAggregateRow {
+    dimensions: Record<string, RuntimeScalar>;
+    metrics: Record<string, string | number | null>;
+}
+export interface RuntimeAggregateRecordsResult {
+    rows: RuntimeAggregateRow[];
+    limit: number;
+    hasMore: boolean;
+}
 export interface RuntimeListWindowOptions {
     cursor?: string;
     limit?: number;