@dxos/compute 0.8.4-main.fd6878d → 0.9.0

package/dist/types/src/errors.d.ts

@@ -0,0 +1,308 @@
+import { BaseError, type BaseErrorOptions } from '@dxos/errors';
+declare const InvokerNotInitializedError_base: {
+    new (options?: BaseErrorOptions): {
+        cause?: unknown;
+        stack?: string;
+        name: "InvokerNotInitializedError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "InvokerNotInitializedError";
+    };
+    isError(error: unknown): error is Error;
+    name: "InvokerNotInitializedError";
+    is(error: unknown): error is BaseError;
+    wrap(options?: Omit<BaseErrorOptions, 'cause'> & {
+        ifTypeDiffers?: boolean;
+    }): (error: unknown) => {
+        cause?: unknown;
+        stack?: string;
+        name: "InvokerNotInitializedError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "InvokerNotInitializedError";
+    };
+    extend<Name extends string = string>(name: Name, message?: string): any;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+    stackTraceLimit: number;
+};
+export declare class InvokerNotInitializedError extends InvokerNotInitializedError_base {
+    constructor();
+}
+declare const NoHandlerError_base: {
+    new (options?: BaseErrorOptions): {
+        cause?: unknown;
+        stack?: string;
+        name: "NoHandlerError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "NoHandlerError";
+    };
+    isError(error: unknown): error is Error;
+    name: "NoHandlerError";
+    is(error: unknown): error is BaseError;
+    wrap(options?: Omit<BaseErrorOptions, 'cause'> & {
+        ifTypeDiffers?: boolean;
+    }): (error: unknown) => {
+        cause?: unknown;
+        stack?: string;
+        name: "NoHandlerError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "NoHandlerError";
+    };
+    extend<Name extends string = string>(name: Name, message?: string): any;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+    stackTraceLimit: number;
+};
+export declare class NoHandlerError extends NoHandlerError_base {
+    constructor(operationKey: string);
+}
+declare const ServiceNotAvailableError_base: {
+    new (options?: BaseErrorOptions): {
+        cause?: unknown;
+        stack?: string;
+        name: "ServiceNotAvailable";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "ServiceNotAvailable";
+    };
+    isError(error: unknown): error is Error;
+    name: "ServiceNotAvailable";
+    is(error: unknown): error is BaseError;
+    wrap(options?: Omit<BaseErrorOptions, 'cause'> & {
+        ifTypeDiffers?: boolean;
+    }): (error: unknown) => {
+        cause?: unknown;
+        stack?: string;
+        name: "ServiceNotAvailable";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "ServiceNotAvailable";
+    };
+    extend<Name extends string = string>(name: Name, message?: string): any;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+    stackTraceLimit: number;
+};
+export declare class ServiceNotAvailableError extends ServiceNotAvailableError_base {
+    constructor(service: string, options?: Omit<BaseErrorOptions, 'context'>);
+}
+declare const FunctionNotFoundError_base: {
+    new (options?: BaseErrorOptions): {
+        cause?: unknown;
+        stack?: string;
+        name: "FunctionNotFound";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "FunctionNotFound";
+    };
+    isError(error: unknown): error is Error;
+    name: "FunctionNotFound";
+    is(error: unknown): error is BaseError;
+    wrap(options?: Omit<BaseErrorOptions, 'cause'> & {
+        ifTypeDiffers?: boolean;
+    }): (error: unknown) => {
+        cause?: unknown;
+        stack?: string;
+        name: "FunctionNotFound";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "FunctionNotFound";
+    };
+    extend<Name extends string = string>(name: Name, message?: string): any;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+    stackTraceLimit: number;
+};
+export declare class FunctionNotFoundError extends FunctionNotFoundError_base {
+    constructor(functionKey: string, options?: Omit<BaseErrorOptions, 'context'>);
+}
+declare const FunctionError_base: {
+    new (options?: BaseErrorOptions): {
+        cause?: unknown;
+        stack?: string;
+        name: "FunctionError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "FunctionError";
+    };
+    isError(error: unknown): error is Error;
+    name: "FunctionError";
+    is(error: unknown): error is BaseError;
+    wrap(options?: Omit<BaseErrorOptions, 'cause'> & {
+        ifTypeDiffers?: boolean;
+    }): (error: unknown) => {
+        cause?: unknown;
+        stack?: string;
+        name: "FunctionError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "FunctionError";
+    };
+    extend<Name extends string = string>(name: Name, message?: string): any;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+    stackTraceLimit: number;
+};
+export declare class FunctionError extends FunctionError_base {
+}
+declare const InvalidOperationInputError_base: {
+    new (options?: BaseErrorOptions): {
+        cause?: unknown;
+        stack?: string;
+        name: "InvalidOperationInput";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "InvalidOperationInput";
+    };
+    isError(error: unknown): error is Error;
+    name: "InvalidOperationInput";
+    is(error: unknown): error is BaseError;
+    wrap(options?: Omit<BaseErrorOptions, 'cause'> & {
+        ifTypeDiffers?: boolean;
+    }): (error: unknown) => {
+        cause?: unknown;
+        stack?: string;
+        name: "InvalidOperationInput";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "InvalidOperationInput";
+    };
+    extend<Name extends string = string>(name: Name, message?: string): any;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+    stackTraceLimit: number;
+};
+export declare class InvalidOperationInputError extends InvalidOperationInputError_base {
+}
+declare const InvalidOperationOutputError_base: {
+    new (options?: BaseErrorOptions): {
+        cause?: unknown;
+        stack?: string;
+        name: "InvalidOperationOutput";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "InvalidOperationOutput";
+    };
+    isError(error: unknown): error is Error;
+    name: "InvalidOperationOutput";
+    is(error: unknown): error is BaseError;
+    wrap(options?: Omit<BaseErrorOptions, 'cause'> & {
+        ifTypeDiffers?: boolean;
+    }): (error: unknown) => {
+        cause?: unknown;
+        stack?: string;
+        name: "InvalidOperationOutput";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "InvalidOperationOutput";
+    };
+    extend<Name extends string = string>(name: Name, message?: string): any;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+    stackTraceLimit: number;
+};
+export declare class InvalidOperationOutputError extends InvalidOperationOutputError_base {
+}
+declare const TriggerStateNotFoundError_base: {
+    new (options?: BaseErrorOptions): {
+        cause?: unknown;
+        stack?: string;
+        name: "TriggerStateNotFound";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "TriggerStateNotFound";
+    };
+    isError(error: unknown): error is Error;
+    name: "TriggerStateNotFound";
+    is(error: unknown): error is BaseError;
+    wrap(options?: Omit<BaseErrorOptions, 'cause'> & {
+        ifTypeDiffers?: boolean;
+    }): (error: unknown) => {
+        cause?: unknown;
+        stack?: string;
+        name: "TriggerStateNotFound";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "TriggerStateNotFound";
+    };
+    extend<Name extends string = string>(name: Name, message?: string): any;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+    stackTraceLimit: number;
+};
+export declare class TriggerStateNotFoundError extends TriggerStateNotFoundError_base {
+}
+declare const FunctionsAiUpstreamError_base: {
+    new (options?: BaseErrorOptions): {
+        cause?: unknown;
+        stack?: string;
+        name: "FunctionsAiUpstreamError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "FunctionsAiUpstreamError";
+    };
+    isError(error: unknown): error is Error;
+    name: "FunctionsAiUpstreamError";
+    is(error: unknown): error is BaseError;
+    wrap(options?: Omit<BaseErrorOptions, 'cause'> & {
+        ifTypeDiffers?: boolean;
+    }): (error: unknown) => {
+        cause?: unknown;
+        stack?: string;
+        name: "FunctionsAiUpstreamError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "FunctionsAiUpstreamError";
+    };
+    extend<Name extends string = string>(name: Name, message?: string): any;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+    stackTraceLimit: number;
+};
+/**
+ * Raised when the upstream AI gateway responds with a structured JSON error envelope
+ * (`{ "type": "error", "error": { "type": ..., "message": ... } }`). Surfaces as a typed
+ * defect from `FunctionsAiHttpClient`, bypassing `@effect/ai`'s generic `HttpResponseError`
+ * wrapping so callers can match on the error class directly.
+ */
+export declare class FunctionsAiUpstreamError extends FunctionsAiUpstreamError_base {
+}
+declare const FunctionsAiMemoizationMissError_base: {
+    new (options?: BaseErrorOptions): {
+        cause?: unknown;
+        stack?: string;
+        name: "FunctionsAiMemoizationMissError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "FunctionsAiMemoizationMissError";
+    };
+    isError(error: unknown): error is Error;
+    name: "FunctionsAiMemoizationMissError";
+    is(error: unknown): error is BaseError;
+    wrap(options?: Omit<BaseErrorOptions, 'cause'> & {
+        ifTypeDiffers?: boolean;
+    }): (error: unknown) => {
+        cause?: unknown;
+        stack?: string;
+        name: "FunctionsAiMemoizationMissError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "FunctionsAiMemoizationMissError";
+    };
+    extend<Name extends string = string>(name: Name, message?: string): any;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+    stackTraceLimit: number;
+};
+/**
+ * Specialized `FunctionsAiUpstreamError` for the memoization layer: the recorded fixture for a
+ * given cache key was not found and `ALLOW_LLM_GENERATION` is unset. The `cacheKey` is exposed
+ * via `context.cacheKey` to make regeneration straightforward.
+ */
+export declare class FunctionsAiMemoizationMissError extends FunctionsAiMemoizationMissError_base {
+}
+export {};
+//# sourceMappingURL=errors.d.ts.map

package/dist/types/src/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/errors.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,SAAS,EAAE,KAAK,gBAAgB,EAAE,MAAM,cAAc,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIhE,qBAAa,0BAA2B,SAAQ,+BAG/C;IACC,cAEC;CACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAED,qBAAa,cAAe,SAAQ,mBAAsE;IACxG,YAAY,YAAY,EAAE,MAAM,EAE/B;CACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAID,qBAAa,wBAAyB,SAAQ,6BAAgE;IAC5G,YAAY,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,IAAI,CAAC,gBAAgB,EAAE,SAAS,CAAC,EAEvE;CACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAED,qBAAa,qBAAsB,SAAQ,0BAA0D;IACnG,YAAY,WAAW,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,IAAI,CAAC,gBAAgB,EAAE,SAAS,CAAC,EAE3E;CACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAED,qBAAa,aAAc,SAAQ,kBAA8D;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEpG,qBAAa,0BAA2B,SAAQ,+BAG/C;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEJ,qBAAa,2BAA4B,SAAQ,gCAGhD;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEJ,qBAAa,yBAA0B,SAAQ,8BAAmE;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAErH;;;;;GAKG;AACH,qBAAa,wBAAyB,SAAQ,6BAG7C;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEJ;;;;GAIG;AACH,qBAAa,+BAAgC,SAAQ,oCAGpD;CAAG"}

package/dist/types/src/index.d.ts

@@ -1,6 +1,19 @@
-export * from './compute-graph';
-export * from './compute-graph-registry';
-export * from './compute-node';
-export * from './functions';
-export * from './types';
+export * from './errors';
+export * as Blueprint from './Blueprint';
+export * as Credential from './Credential';
+export * as Header from './Header';
+export * as McpServer from './McpServer';
+export * as LayerSpec from './LayerSpec';
+export * as Operation from './Operation';
+export * as OperationHandlerSet from './OperationHandlerSet';
+export * as OperationRegistry from './OperationRegistry';
+export * as Process from './Process';
+export * as Routine from './Routine';
+export * as Script from './Script';
+export * as ServiceResolver from './ServiceResolver';
+export * as StorageService from './StorageService';
+export * as Template from './Template';
+export * as Trace from './Trace';
+export * as Trigger from './Trigger';
+export * as TriggerEvent from './TriggerEvent';
 //# sourceMappingURL=index.d.ts.map

package/dist/types/src/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":"AA+BA,cAAc,iBAAiB,CAAC;AAChC,cAAc,0BAA0B,CAAC;AACzC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,aAAa,CAAC;AAC5B,cAAc,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":"AAIA,cAAc,UAAU,CAAC;AAEzB,OAAO,KAAK,SAAS,MAAM,aAAa,CAAC;AACzC,OAAO,KAAK,UAAU,MAAM,cAAc,CAAC;AAC3C,OAAO,KAAK,MAAM,MAAM,UAAU,CAAC;AACnC,OAAO,KAAK,SAAS,MAAM,aAAa,CAAC;AACzC,OAAO,KAAK,SAAS,MAAM,aAAa,CAAC;AACzC,OAAO,KAAK,SAAS,MAAM,aAAa,CAAC;AACzC,OAAO,KAAK,mBAAmB,MAAM,uBAAuB,CAAC;AAC7D,OAAO,KAAK,iBAAiB,MAAM,qBAAqB,CAAC;AACzD,OAAO,KAAK,OAAO,MAAM,WAAW,CAAC;AACrC,OAAO,KAAK,OAAO,MAAM,WAAW,CAAC;AACrC,OAAO,KAAK,MAAM,MAAM,UAAU,CAAC;AACnC,OAAO,KAAK,eAAe,MAAM,mBAAmB,CAAC;AACrD,OAAO,KAAK,cAAc,MAAM,kBAAkB,CAAC;AACnD,OAAO,KAAK,QAAQ,MAAM,YAAY,CAAC;AACvC,OAAO,KAAK,KAAK,MAAM,SAAS,CAAC;AACjC,OAAO,KAAK,OAAO,MAAM,WAAW,CAAC;AACrC,OAAO,KAAK,YAAY,MAAM,gBAAgB,CAAC"}

package/dist/types/src/testing/definitions.d.ts

@@ -0,0 +1,11 @@
+import * as Operation from '../Operation';
+export declare const Fibonacci: Operation.Definition<{
+    readonly iterations?: number | undefined;
+}, {
+    readonly result: string;
+}, never>;
+export declare const Reply: Operation.Definition<any, any, never>;
+export declare const Sleep: Operation.Definition<{
+    readonly duration?: number | undefined;
+}, void, never>;
+//# sourceMappingURL=definitions.d.ts.map

package/dist/types/src/testing/definitions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definitions.d.ts","sourceRoot":"","sources":["../../../../src/testing/definitions.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,SAAS,MAAM,cAAc,CAAC;AAE1C,eAAO,MAAM,SAAS;;;;SAepB,CAAC;AAEH,eAAO,MAAM,KAAK,uCAQhB,CAAC;AAEH,eAAO,MAAM,KAAK;;eAahB,CAAC"}

package/dist/types/src/testing/fib.d.ts

@@ -0,0 +1,8 @@
+import * as Operation from '../Operation';
+declare const _default: Operation.WithHandler<Operation.Definition<{
+    readonly iterations?: number | undefined;
+}, {
+    readonly result: string;
+}, never>>;
+export default _default;
+//# sourceMappingURL=fib.d.ts.map

package/dist/types/src/testing/fib.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fib.d.ts","sourceRoot":"","sources":["../../../../src/testing/fib.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,SAAS,MAAM,cAAc,CAAC"}

package/dist/types/src/testing/index.d.ts

@@ -1,4 +1,7 @@
-export * from './test-builder';
-export * from './test-plugin';
-export * from './util';
+import * as OperationHandlerSet from '../OperationHandlerSet';
+export { Fibonacci, Reply, Sleep } from './definitions';
+export { default as FibonacciHandler } from './fib';
+export { default as ReplyHandler } from './reply';
+export { default as SleepHandler } from './sleep';
+export declare const ExampleHandlers: OperationHandlerSet.OperationHandlerSet;
 //# sourceMappingURL=index.d.ts.map

package/dist/types/src/testing/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/testing/index.ts"],"names":[],"mappings":"AAIA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,eAAe,CAAC;AAC9B,cAAc,QAAQ,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/testing/index.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,mBAAmB,MAAM,wBAAwB,CAAC;AAE9D,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AACxD,OAAO,EAAE,OAAO,IAAI,gBAAgB,EAAE,MAAM,OAAO,CAAC;AACpD,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,SAAS,CAAC;AAClD,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,SAAS,CAAC;AAElD,eAAO,MAAM,eAAe,yCAI3B,CAAC"}

package/dist/types/src/testing/reply.d.ts

@@ -0,0 +1,4 @@
+import * as Operation from '../Operation';
+declare const _default: Operation.WithHandler<Operation.Definition<any, any, never>>;
+export default _default;
+//# sourceMappingURL=reply.d.ts.map

package/dist/types/src/testing/reply.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reply.d.ts","sourceRoot":"","sources":["../../../../src/testing/reply.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,SAAS,MAAM,cAAc,CAAC"}

package/dist/types/src/testing/sleep.d.ts

@@ -0,0 +1,6 @@
+import * as Operation from '../Operation';
+declare const _default: Operation.WithHandler<Operation.Definition<{
+    readonly duration?: number | undefined;
+}, void, never>>;
+export default _default;
+//# sourceMappingURL=sleep.d.ts.map

package/dist/types/src/testing/sleep.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sleep.d.ts","sourceRoot":"","sources":["../../../../src/testing/sleep.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,SAAS,MAAM,cAAc,CAAC"}

package/dist/types/src/umbrella.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=umbrella.test.d.ts.map

package/dist/types/src/umbrella.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"umbrella.test.d.ts","sourceRoot":"","sources":["../../../src/umbrella.test.ts"],"names":[],"mappings":""}