@m4trix/core 0.10.0 → 0.11.0

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 export { HttpStreamOptions, MessageStream, Pump, Source, StreamChunk, StreamTransformer, ensureFullWords, httpStreamResponse } from './stream/index.js';
 export { BaseMessage, Message, Role, SocketEventName, SocketIoFactory, TextMessage, VoiceMessage } from './api/index.js';
 export { FormatType, MessageFilterType, TransformMessages } from './helper/index.js';
-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 } from './matrix/index.js';
+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 } from './matrix/index.js';
 export { Schema as S } from 'effect';
 import 'socket.io';
 import '@langchain/core/messages';

package/dist/index.js

@@ -1823,6 +1823,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) {
@@ -2033,6 +2184,6 @@ var consoleTracerLayer = Layer.setTracer(
   consoleTracer
 );
 
-export { Agent, AgentFactory, AgentNetwork, AgentNetworkEvent, Channel, ChannelName, ConfiguredChannel, EventMetaSchema, ExposeAuthError, ExpressEndpoint, NextEndpoint, Pump, Sink, SocketIoFactory, TransformMessages, consoleTracer, consoleTracerLayer, ensureFullWords, formatSSE, httpStreamResponse, isHttpStreamSink, toSSEStream };
+export { Agent, AgentFactory, AgentNetwork, AgentNetworkEvent, Channel, ChannelName, ConfiguredChannel, EventMetaSchema, ExposeAuthError, ExpressEndpoint, LayerName, NextEndpoint, Pump, Sink, Skill, SkillDependency, SocketIoFactory, TransformMessages, consoleTracer, consoleTracerLayer, ensureFullWords, formatSSE, httpStreamResponse, isHttpStreamSink, toSSEStream };
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.js.map