@m4trix/core 0.10.0 → 0.11.1

package/dist/index.d.ts

@@ -1,8 +1,80 @@
 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';
+import { Socket } from 'socket.io';
 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';
 import 'effect/ParseResult';
+
+type Role = 'system' | 'user' | 'assistant' | string;
+interface BaseMessage {
+    /** Unique across the conversation */
+    id: string;
+    role: Role;
+    /** ISO string or Date; normalized when you receive it */
+    timestamp: string;
+}
+interface TextMessage extends BaseMessage {
+    kind: 'text';
+    /** two modes: plain vs. structured */
+    content: string | {
+        format: 'markdown' | 'html';
+        body: string;
+    };
+}
+interface VoiceMessage extends BaseMessage {
+    kind: 'voice';
+    /** raw bytes or reference */
+    data: ArrayBuffer | Blob;
+    format: 'mp3' | 'wav' | string;
+    durationMs: number;
+    /** optional transcript if you run speech-to-text */
+    transcript?: string;
+}
+type Message = TextMessage | VoiceMessage;
+
+type SocketEventName = 'conversation:create' | 'voice:input_file' | 'voice:input_chunk' | 'voice:input_commit' | 'voice:output_delta' | 'voice:output_commit' | 'voice:output_file' | 'voice:output_transcript_delta' | 'voice:output_transcript_full';
+
+type HookContext<T> = {
+    socket: T;
+    hooks: Hooks<T>;
+};
+type Hooks<SocketType> = {
+    onConversationCreated?: (conversationId: string, context: HookContext<SocketType>) => void;
+    onVoiceInputFile?: (file: Blob | Uint8Array, context: HookContext<SocketType>) => void;
+    onVoiceInputChunk?: (chunk: Uint8Array, context: HookContext<SocketType>) => void;
+    onVoiceInputCommit?: (context: HookContext<SocketType>) => void;
+    onVoiceOutputDelta?: (chunk: Uint8Array, context: HookContext<SocketType>) => void;
+    onVoiceOutputCommit?: (context: HookContext<SocketType>) => void;
+    onVoiceOutputFile?: (file: Blob | Uint8Array, context: HookContext<SocketType>) => void;
+    onVoiceOutputTranscriptDelta?: (transcriptChunk: string, context: HookContext<SocketType>) => void;
+    onVoiceOutputTranscriptFull?: (transcript: string, context: HookContext<SocketType>) => void;
+};
+type BaseSetupSocketHandlersParams<SocketType> = {
+    enableVoiceEvents: boolean;
+    enableChatEvents: boolean;
+    enableTranscriptEvents: boolean;
+    prefix?: string;
+    hooks?: Hooks<SocketType>;
+};
+/**
+ * Extra keys supplied by the caller are kept,
+ * but if they collide with a base key the base type wins.
+ */
+type SetupSocketHandlersParams<SocketType, Extra = Record<string, never>> = Omit<Extra, keyof BaseSetupSocketHandlersParams<SocketType>> & BaseSetupSocketHandlersParams<SocketType>;
+
+declare class SocketIoFactory {
+    private socket;
+    private prefix;
+    private hooks;
+    private constructor();
+    static setupSocketHandlers({ enableVoiceEvents, enableChatEvents, enableTranscriptEvents, prefix, socket, hooks, }: SetupSocketHandlersParams<Socket, {
+        socket: Socket;
+    }>): void;
+    private setupVoiceEvents;
+    private setupChatEvents;
+    private setupTranscriptEvents;
+    private prefixEvent;
+}
+
+export { BaseMessage, Message, Role, SocketEventName, SocketIoFactory, TextMessage, VoiceMessage };

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