@m4trix/core 0.10.0 → 0.11.0

package/dist/matrix/index.d.ts

@@ -401,6 +401,77 @@ declare class AgentNetwork {
     private runScoped;
 }
 
+/**
+ * Branded type for layer/dependency names. Enforces camelCase at runtime via refinement.
+ * Used internally for parsing, validation, and uniqueness enforcement across layers.
+ */
+type LayerName = string & Brand.Brand<'LayerName'>;
+declare const LayerName: Brand.Brand.Constructor<LayerName>;
+/** Definition of a single skill dependency with a branded name and schema shape */
+type SkillDependencyDef<N extends string, PS extends Schema.Schema.Any> = {
+    readonly _tag: 'SkillDependencyDef';
+    readonly name: LayerName;
+    readonly _name: N;
+    readonly shape: PS;
+    readonly decode: (u: unknown) => Effect.Effect<Schema.Schema.Type<PS>, ParseError>;
+};
+/** Build layers object type from a tuple of dependency definitions */
+type DependenciesToLayers<T> = T extends SkillDependencyDef<infer N, infer PS> ? {
+    [K in N]: Schema.Schema.Type<PS>;
+} : never;
+type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+/** Build layers object from union of dependency types */
+type LayersFromDeps<T extends SkillDependencyDef<string, Schema.Schema.Any>> = [T] extends [never] ? Record<string, never> : UnionToIntersection<DependenciesToLayers<T>>;
+declare const SkillDependency: {
+    of<const N extends string, PS extends Schema.Schema.Any>(config: {
+        name: N;
+        shape: PS;
+    }): SkillDependencyDef<N, PS>;
+};
+/** Minimal runtime options placeholder (logger, trace, etc. can be extended later) */
+type SkillRuntimeOptions = Record<string, unknown>;
+/** Context passed to the define callback */
+type SkillDefineContext<TIn, TChunk, TLayers> = {
+    input: TIn;
+    emit: (chunk: TChunk) => void;
+    layers: TLayers;
+};
+/** Define function signature */
+type DefineFn<TIn, TChunk, TDone, TLayers> = (ctx: SkillDefineContext<TIn, TChunk, TLayers>) => TDone | Promise<TDone>;
+/** Final executable skill instance */
+type SkillInstance<TInput, TChunk, TDone, TLayers> = {
+    invokeStream: (input: unknown, runtime?: {
+        layers: TLayers;
+    } & SkillRuntimeOptions) => AsyncIterable<TChunk | {
+        _tag: 'Done';
+        done: TDone;
+    }>;
+    /** Input is decoded to TInput before being passed to the skill logic */
+    invoke: (input: unknown, runtime?: {
+        layers: TLayers;
+    } & SkillRuntimeOptions) => Promise<{
+        chunks: TChunk[];
+        done: TDone;
+    }>;
+} & {
+    readonly _input?: TInput;
+};
+declare class Skill<TInput = unknown, TChunk = unknown, TDone = unknown, TDeps extends SkillDependencyDef<string, Schema.Schema.Any> = never> {
+    private _inputSchema;
+    private _chunkSchema;
+    private _doneSchema;
+    private _layers;
+    private _defineFn;
+    private constructor();
+    private getState;
+    static of(_options?: SkillRuntimeOptions): Skill<unknown, unknown, unknown, never>;
+    input<ISchema extends Schema.Schema.Any>(schema: ISchema): Skill<Schema.Schema.Type<ISchema>, TChunk, TDone, TDeps>;
+    chunk<CSchema extends Schema.Schema.Any>(schema: CSchema): Skill<TInput, Schema.Schema.Type<CSchema>, TDone, TDeps>;
+    done<DSchema extends Schema.Schema.Any>(schema: DSchema): Skill<TInput, TChunk, Schema.Schema.Type<DSchema>, TDeps>;
+    use<D extends SkillDependencyDef<string, Schema.Schema.Any>>(...layers: [D, ...D[]] | [ReadonlyArray<D>]): Skill<TInput, TChunk, TDone, TDeps | D>;
+    define(fn: DefineFn<TInput, TChunk, TDone, LayersFromDeps<TDeps>>): SkillInstance<TInput, TChunk, TDone, LayersFromDeps<TDeps>>;
+}
+
 /** Thrown when auth denies the request */
 declare class ExposeAuthError extends Error {
     readonly status: number;
@@ -501,4 +572,4 @@ declare const consoleTracer: Tracer.Tracer;
  */
 declare const consoleTracerLayer: Layer.Layer<never>;
 
-export { Agent, AgentBinding, AgentFactory, AgentNetwork, AgentNetworkEvent, AgentNetworkEventDef, AnyAgent, AuthResult, Channel, ChannelDef, ChannelName, ConfiguredChannel, ContextEvents, EmitPayload, EnvelopeLike, EventEnvelope, EventMeta, EventMetaSchema, EventPlane, ExposeAuthError, ExposeOptions, ExposeRequest, ExposeSelect, ExposedAPI, ExposedStream, ExpressEndpoint, ExpressEndpointOptions, ExpressHandler, ExpressRequest, ExpressResponse, NextEndpoint, NextEndpointOptions, NextGetHandler, OnRequestContext, RunEvents, SetupContext, Sink, SinkDef, SpawnCallbackContext, SpawnFn, SpawnerBuilder, StreamFactory, UnboundEvent, consoleTracer, consoleTracerLayer, formatSSE, isHttpStreamSink, toSSEStream };
+export { Agent, AgentBinding, AgentFactory, AgentNetwork, AgentNetworkEvent, AgentNetworkEventDef, AnyAgent, AuthResult, Channel, ChannelDef, ChannelName, ConfiguredChannel, ContextEvents, EmitPayload, EnvelopeLike, EventEnvelope, EventMeta, EventMetaSchema, EventPlane, ExposeAuthError, ExposeOptions, ExposeRequest, ExposeSelect, ExposedAPI, ExposedStream, ExpressEndpoint, ExpressEndpointOptions, ExpressHandler, ExpressRequest, ExpressResponse, LayerName, LayersFromDeps, NextEndpoint, NextEndpointOptions, NextGetHandler, OnRequestContext, RunEvents, SetupContext, Sink, SinkDef, Skill, SkillDefineContext, SkillDependency, SkillDependencyDef, SkillInstance, SkillRuntimeOptions, SpawnCallbackContext, SpawnFn, SpawnerBuilder, StreamFactory, UnboundEvent, consoleTracer, consoleTracerLayer, formatSSE, isHttpStreamSink, toSSEStream };

package/dist/matrix/index.js

@@ -766,6 +766,157 @@ var AgentFactory = class _AgentFactory {
     );
   }
 };
+var CAMEL_CASE_REGEX = /^[a-z][a-zA-Z0-9]*$/;
+var LayerName = Brand.refined(
+  (s) => typeof s === "string" && CAMEL_CASE_REGEX.test(s),
+  (s) => Brand.error(`Expected camelCase (e.g. myLayerFoo), got: ${s}`)
+);
+var SkillDependency = {
+  of(config) {
+    const name = LayerName(config.name);
+    const decode = Schema.decodeUnknown(config.shape);
+    return {
+      _tag: "SkillDependencyDef",
+      name,
+      _name: config.name,
+      shape: config.shape,
+      decode
+    };
+  }
+};
+function toLayerArray(layers) {
+  if (layers.length === 1 && Array.isArray(layers[0])) {
+    return layers[0];
+  }
+  return [...layers];
+}
+function assertUniqueLayerNames(layers) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const dep of layers) {
+    const key = dep.name;
+    if (seen.has(key)) {
+      throw new Error(`Duplicate layer name: ${key}`);
+    }
+    seen.add(key);
+  }
+}
+var Skill = class _Skill {
+  constructor(params) {
+    this._inputSchema = params.inputSchema;
+    this._chunkSchema = params.chunkSchema;
+    this._doneSchema = params.doneSchema;
+    this._layers = params.layers;
+    this._defineFn = params.defineFn;
+  }
+  getState() {
+    return {
+      inputSchema: this._inputSchema,
+      chunkSchema: this._chunkSchema,
+      doneSchema: this._doneSchema,
+      layers: this._layers,
+      defineFn: this._defineFn
+    };
+  }
+  static of(_options) {
+    return new _Skill({
+      layers: []
+    });
+  }
+  input(schema) {
+    return new _Skill({
+      ...this.getState(),
+      inputSchema: schema
+    });
+  }
+  chunk(schema) {
+    return new _Skill({
+      ...this.getState(),
+      chunkSchema: schema
+    });
+  }
+  done(schema) {
+    return new _Skill({
+      ...this.getState(),
+      doneSchema: schema
+    });
+  }
+  use(...layers) {
+    const normalized = toLayerArray(layers);
+    const allLayers = [...this._layers, ...normalized];
+    assertUniqueLayerNames(allLayers);
+    return new _Skill({
+      ...this.getState(),
+      layers: allLayers
+    });
+  }
+  define(fn) {
+    const state = this.getState();
+    const inputSchema = state.inputSchema;
+    const chunkSchema = state.chunkSchema;
+    const doneSchema = state.doneSchema;
+    const defineFn = fn;
+    if (!inputSchema || !chunkSchema || !doneSchema || !defineFn) {
+      throw new Error(
+        "Skill.define requires input(), chunk(), and done() to be called before define()"
+      );
+    }
+    const decodeInput = Schema.decodeUnknown(inputSchema);
+    const decodeChunk = Schema.decodeUnknown(chunkSchema);
+    const decodeDone = Schema.decodeUnknown(doneSchema);
+    const runDefine = async (input, runtime) => {
+      const layersObj = runtime?.layers ?? {};
+      const chunks = [];
+      const emit = (chunk) => {
+        const decoded = Effect.runSync(
+          decodeChunk(chunk)
+        );
+        chunks.push(decoded);
+      };
+      const done = await defineFn({
+        input,
+        emit,
+        layers: layersObj
+      });
+      const decodedDone = Effect.runSync(
+        decodeDone(done)
+      );
+      return { chunks, done: decodedDone };
+    };
+    return {
+      invokeStream: async function* (input, runtime) {
+        const decodedInput = Effect.runSync(
+          decodeInput(input)
+        );
+        const layersObj = runtime?.layers ?? {};
+        const chunks = [];
+        const emit = (chunk) => {
+          const decoded = Effect.runSync(
+            decodeChunk(chunk)
+          );
+          chunks.push(decoded);
+        };
+        const done = await defineFn({
+          input: decodedInput,
+          emit,
+          layers: layersObj
+        });
+        const decodedDone = Effect.runSync(
+          decodeDone(done)
+        );
+        for (const c of chunks) {
+          yield c;
+        }
+        yield { _tag: "Done", done: decodedDone };
+      },
+      invoke: async (input, runtime) => {
+        const decodedInput = Effect.runSync(
+          decodeInput(input)
+        );
+        return runDefine(decodedInput, runtime);
+      }
+    };
+  }
+};
 
 // src/matrix/io/protocols/sse.ts
 function formatSSE(envelope) {
@@ -976,6 +1127,6 @@ var consoleTracerLayer = Layer.setTracer(
   consoleTracer
 );
 
-export { Agent, AgentFactory, AgentNetwork, AgentNetworkEvent, Channel, ChannelName, ConfiguredChannel, EventMetaSchema, ExposeAuthError, ExpressEndpoint, NextEndpoint, Sink, consoleTracer, consoleTracerLayer, formatSSE, isHttpStreamSink, toSSEStream };
+export { Agent, AgentFactory, AgentNetwork, AgentNetworkEvent, Channel, ChannelName, ConfiguredChannel, EventMetaSchema, ExposeAuthError, ExpressEndpoint, LayerName, NextEndpoint, Sink, Skill, SkillDependency, consoleTracer, consoleTracerLayer, formatSSE, isHttpStreamSink, toSSEStream };
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.js.map