@agent-glue/glue 0.1.0

package/.turbo/turbo-build.log

@@ -0,0 +1,5 @@
+
+
+> @agent-glue/glue@0.1.0 build /home/gareth/Documents/Personal/2025/agent-glue/packages/agent-glue
+> tsc
+

package/.turbo/turbo-clean$colon$build.log

@@ -0,0 +1 @@
+

package/.turbo/turbo-format$colon$fix.log

@@ -0,0 +1,46 @@
+
+
+> @agent-glue/glue@0.1.0 format:fix /home/gareth/Documents/Personal/2025/agent-glue/packages/agent-glue
+> prettier --write .
+
+CHANGELOG.mdCHANGELOG.md 44ms
+dist/Actor.d.tsdist/Actor.d.ts 233ms
+dist/actor.jsdist/actor.js 66ms
+dist/Actor.jsdist/Actor.js 9ms
+dist/actors/examples/timer.d.tsdist/actors/examples/timer.d.ts 4ms
+dist/actors/examples/timer.jsdist/actors/examples/timer.js 2ms
+dist/actors/langchain/llm.d.tsdist/actors/langchain/llm.d.ts 19ms
+dist/actors/langchain/llm.jsdist/actors/langchain/llm.js 24ms
+dist/constructors.jsdist/constructors.js 4ms
+dist/effects.jsdist/effects.js 18ms
+dist/emitter.jsdist/emitter.js 7ms
+dist/index.d.tsdist/index.d.ts 4ms
+dist/index.jsdist/index.js 2ms
+dist/message.jsdist/message.js 5ms
+dist/message.test.jsdist/message.test.js 10ms
+dist/server.jsdist/server.js 2ms
+dist/server/memory.jsdist/server/memory.js 10ms
+dist/server/protocol.jsdist/server/protocol.js 4ms
+dist/server/websocket.jsdist/server/websocket.js 14ms
+dist/transformers.d.tsdist/transformers.d.ts 14ms
+dist/transformers.jsdist/transformers.js 4ms
+dist/types.jsdist/types.js 2ms
+dist/utils/TypedEmitter.d.tsdist/utils/TypedEmitter.d.ts 6ms
+dist/utils/TypedEmitter.jsdist/utils/TypedEmitter.js 2ms
+eslint.config.jseslint.config.js 3ms
+nodemon.jsonnodemon.json 3ms
+package.jsonpackage.json 3ms
+src/actor.tssrc/actor.ts 22ms
+src/effects.tssrc/effects.ts 23ms
+src/emitter.tssrc/emitter.ts 10ms
+src/index.tssrc/index.ts 2ms
+src/message.test.tssrc/message.test.ts 16ms
+src/message.tssrc/message.ts 14ms
+src/server.tssrc/server.ts 2ms
+src/server/memory.tssrc/server/memory.ts 18ms
+src/server/protocol.tssrc/server/protocol.ts 7ms
+src/server/websocket.tssrc/server/websocket.ts 23ms
+src/transformers.tssrc/transformers.ts 10ms
+src/types.tssrc/types.ts 3ms
+src/utils/TypedEmitter.tssrc/utils/TypedEmitter.ts 5ms
+tsconfig.jsontsconfig.json 2ms

package/.turbo/turbo-format.log

@@ -0,0 +1,13 @@
+
+
+> @agent-glue/glue@0.1.0 format /home/gareth/Documents/Personal/2025/agent-glue/packages/agent-glue
+> prettier --check .
+
+Checking formatting...
+CHANGELOG.mddist/Actor.d.tsdist/actor.js[warn] dist/actor.js
+dist/Actor.js[warn] dist/Actor.js
+dist/actors/examples/timer.d.tsdist/actors/examples/timer.jsdist/actors/langchain/llm.d.tsdist/actors/langchain/llm.jsdist/constructors.jsdist/effects.js[warn] dist/effects.js
+dist/emitter.js[warn] dist/emitter.js
+dist/index.d.tsdist/index.jsdist/message.js[warn] dist/message.js
+dist/message.test.js[warn] dist/message.test.js
+dist/server.jsdist/server/memory.js

package/.turbo/turbo-lint$colon$fix.log

@@ -0,0 +1,9 @@
+
+
+> @agent-glue/glue@0.1.0 lint:fix /home/gareth/Documents/Personal/2025/agent-glue/packages/agent-glue
+> pnpm lint --fix
+
+
+> @agent-glue/glue@0.1.0 lint /home/gareth/Documents/Personal/2025/agent-glue/packages/agent-glue
+> eslint . "--fix"
+

package/.turbo/turbo-lint.log

@@ -0,0 +1,5 @@
+
+
+> @agent-glue/glue@0.1.0 lint /home/gareth/Documents/Personal/2025/agent-glue/packages/agent-glue
+> eslint .
+

package/.turbo/turbo-test.log

@@ -0,0 +1,27 @@
+
+
+> @agent-glue/glue@0.0.1 test /home/gareth/Documents/Personal/2025/agent-glue/packages/agent-glue
+> vitest
+
+[?25l
+ DEV  v3.0.4 /home/gareth/Documents/Personal/2025/agent-glue/packages/agent-glue
+
+[?2026h
+ ❯ src/message.test.ts [queued]
+
+ Test Files 0 passed (1)
+      Tests 0 passed (0)
+   Start at 03:32:17
+   Duration 200ms
+[?2026l ✓ src/message.test.ts (3 tests) 5ms
+   ✓ defineMessage > should create a message definition and type guard
+   ✓ defineMessage > is > should allow checking if a message is of the defined type
+   ✓ defineMessage > message > should provide a message builder function
+
+ Test Files  1 passed (1)
+      Tests  3 passed (3)
+   Start at  03:32:17
+   Duration  401ms (transform 64ms, setup 0ms, collect 64ms, tests 5ms, environment 0ms, prepare 98ms)
+
+ PASS  Waiting for file changes...
+       press h to show help, press q to quit

package/.turbo/turbo-typecheck.log

@@ -0,0 +1,5 @@
+
+
+> @agent-glue/glue@0.1.0 typecheck /home/gareth/Documents/Personal/2025/agent-glue/packages/agent-glue
+> tsc --noEmit
+

package/CHANGELOG.md

@@ -0,0 +1,7 @@
+# @agent-glue/glue
+
+## 0.1.0
+
+### Minor Changes
+
+- Initial release

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Gareth Andrew
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/Actor.d.ts

@@ -0,0 +1,51 @@
+export interface Message {
+  id: string;
+  type: string;
+}
+export declare function isMessageType<T extends Message>(
+  type: T["type"]
+): (message: Message) => message is T;
+export declare function message<T extends Message>(
+  type: T["type"]
+): (
+  message: Omit<T, "id" | "type"> & {
+    id?: string;
+    type?: string;
+  }
+) => T;
+export interface ActorInterface<
+  Commands extends Message,
+  Events extends Message
+> {
+  send(command: Commands): void;
+  connect(handler: (event: Events) => void): void;
+  disconnect(handler: (event: Events) => void): void;
+}
+export declare abstract class Actor<
+  Commands extends Message = never,
+  Events extends Message = never
+> implements ActorInterface<Commands, Events>
+{
+  private readonly emitter;
+  protected emit(event: Events): void;
+  send(_command: Commands): void;
+  connect(handler: (event: Events) => void): void;
+  disconnect(handler: (event: Events) => void): void;
+}
+export type CommandsType<T extends ActorInterface<Message, Message>> =
+  T extends ActorInterface<infer C, Message> ? C : never;
+export type ActorFunction<
+  Commands extends Message = never,
+  Events extends Message = never
+> = (emit: (event: Events) => void) => (command: Commands) => void;
+export declare class FunctionActor<
+  Commands extends Message = never,
+  Events extends Message = never
+> extends Actor<Commands, Events> {
+  private readonly fn;
+  constructor(fn: ActorFunction<Commands, Events>);
+  send(command: Commands): void;
+}
+export declare function actor<Commands extends Message, Events extends Message>(
+  fn: ActorFunction<Commands, Events>
+): ActorInterface<Commands, Events>;

package/dist/Actor.js

@@ -0,0 +1,30 @@
+import { TypedEmitter } from "./utils/TypedEmitter.js";
+export class Actor {
+  emitter = new TypedEmitter();
+  emit(event) {
+    this.emitter.emit("event", event);
+  }
+  send(_command) {
+    return;
+  }
+  connect(handler) {
+    this.emitter.on("event", handler);
+  }
+  disconnect(handler) {
+    this.emitter.off("event", handler);
+  }
+}
+export class FunctionActor extends Actor {
+  fn;
+  constructor(fn) {
+    super();
+    this.fn = fn;
+  }
+  send(command) {
+    const emit = (event) => this.emit(event);
+    this.fn(emit)(command);
+  }
+}
+export function actor(fn) {
+  return new FunctionActor(fn);
+}

package/dist/actor.js

@@ -0,0 +1,32 @@
+import { Emitter } from "./emitter.js";
+export class Actor {
+    emitter = new Emitter();
+    emit(event) {
+        this.emitter.emit(event);
+    }
+    send(_command) {
+        return;
+    }
+    connect(handler) {
+        return this.emitter.connect(handler);
+    }
+    disconnect(handler) {
+        this.emitter.disconnect(handler);
+    }
+}
+export class FunctionActor extends Actor {
+    constructor(fn) {
+        super();
+        this.send = fn(this.emit.bind(this));
+    }
+}
+export function actor(fn) {
+    return new FunctionActor(fn);
+}
+export function actorClass(handler) {
+    return class extends FunctionActor {
+        constructor() {
+            super(handler);
+        }
+    };
+}

package/dist/actors/examples/timer.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/actors/examples/timer.js

@@ -0,0 +1 @@
+export {};

package/dist/actors/langchain/llm.d.ts

@@ -0,0 +1,40 @@
+import { BaseChatModel } from "@langchain/core/language_models/chat_models";
+import { AIMessage, BaseMessage } from "@langchain/core/messages";
+import { Actor, Message } from "../../Actor.js";
+export declare const GENERATE_COMMAND_TYPE = "langchain.llm.generate";
+export interface GenerateCommand extends Message {
+  type: typeof GENERATE_COMMAND_TYPE;
+  model: BaseChatModel;
+  messages: BaseMessage[];
+}
+export declare const generateCommand: (
+  message: Omit<GenerateCommand, "type" | "id"> & {
+    id?: string;
+    type?: string;
+  }
+) => GenerateCommand;
+export declare const isGenerateCommand: (
+  message: Message
+) => message is GenerateCommand;
+export declare const RESPONSE_EVENT_TYPE = "langchain.llm.response";
+export interface ResponseEvent extends Message {
+  type: typeof RESPONSE_EVENT_TYPE;
+  requestId: string;
+  response: AIMessage;
+}
+export declare const responseEvent: (
+  message: Omit<ResponseEvent, "type" | "id"> & {
+    id?: string;
+    type?: string;
+  }
+) => ResponseEvent;
+export declare const isResponseEvent: (
+  message: Message
+) => message is ResponseEvent;
+export type LLMCommands = GenerateCommand;
+export type LLMEvents = ResponseEvent;
+export declare class LLMActor extends Actor<LLMCommands, LLMEvents> {
+  send(cmd: LLMCommands): Promise<void>;
+}
+export declare const withPromptCaching: any;
+export declare const wihMessageTruncation: any;

package/dist/actors/langchain/llm.js

@@ -0,0 +1,52 @@
+import { AIMessage } from "@langchain/core/messages";
+import { Actor, isMessageType, message } from "../../Actor.js";
+import { applyCachingToMessages } from "../../llm/messageTools.js";
+import {
+  commandTransformer,
+  eventTransformer
+} from "../../glue/transformers.js";
+export const GENERATE_COMMAND_TYPE = "langchain.llm.generate";
+export const generateCommand = message(GENERATE_COMMAND_TYPE);
+export const isGenerateCommand = isMessageType(GENERATE_COMMAND_TYPE);
+export const RESPONSE_EVENT_TYPE = "langchain.llm.response";
+export const responseEvent = message(RESPONSE_EVENT_TYPE);
+export const isResponseEvent = isMessageType(RESPONSE_EVENT_TYPE);
+export class LLMActor extends Actor {
+  async send(cmd) {
+    const msg = await cmd.model.invoke(cmd.messages);
+    this.emit({
+      type: "langchain.llm.response",
+      requestId: cmd.id,
+      response: msg
+    });
+  }
+}
+export const withPromptCaching = commandTransformer((cmd) => {
+  if (!isGenerateCommand(cmd)) {
+    return cmd;
+  }
+  return generateCommand({
+    ...cmd,
+    messages: applyCachingToMessages(cmd.messages)
+  });
+});
+const truncateMaxTokens = (message) => {
+  if (!isResponseEvent(message)) {
+    return message;
+  }
+  let response = message.response;
+  const stopReason = response.response_metadata["stop_reason"];
+  if (stopReason === "max_tokens") {
+    // In all cases so far, when we hit max_tokens there are multiple tool calls so we can just skip the last one and assume
+    // the agent will try again in the next message
+    response = new AIMessage({
+      content: response.content && response.content.slice(0, -1),
+      tool_calls: response.tool_calls && response.tool_calls.slice(0, -1)
+    });
+  }
+  return responseEvent({
+    ...message,
+    response
+  });
+};
+export const wihMessageTruncation = eventTransformer(truncateMaxTokens);

package/dist/constructors.js

@@ -0,0 +1 @@
+export {};

package/dist/effects.js

@@ -0,0 +1,66 @@
+function defaultDiscriminator(m) {
+    return m === m;
+}
+export function take(actor, discriminator = defaultDiscriminator) {
+    return new Promise((resolve) => {
+        const handler = (message) => {
+            if (discriminator(message)) {
+                actor.disconnect(handler);
+                resolve(message);
+            }
+        };
+        actor.connect(handler);
+    });
+}
+export async function* takeEvery(actor) {
+    const eventQueue = [];
+    let resolve = null;
+    const disconnect = actor.connect((message) => {
+        if (resolve) {
+            resolve(message);
+            resolve = null;
+        }
+        else {
+            eventQueue.push(message);
+        }
+    });
+    try {
+        while (true) {
+            if (eventQueue.length > 0) {
+                yield eventQueue.shift();
+            }
+            else {
+                yield new Promise((res) => {
+                    resolve = res;
+                });
+            }
+        }
+    }
+    finally {
+        disconnect();
+    }
+}
+export async function* takeIf(actor, discriminator) {
+    for await (const event of takeEvery(actor)) {
+        if (discriminator(event)) {
+            yield event;
+        }
+    }
+}
+export async function* takeUntil(actor, discriminator, endCondition = () => true) {
+    for await (const event of takeEvery(actor)) {
+        if (endCondition(event)) {
+            break;
+        }
+        if (discriminator(event)) {
+            yield event;
+        }
+    }
+}
+export function on(actor, discriminator, handler) {
+    return actor.connect((message) => {
+        if (discriminator(message)) {
+            handler(message);
+        }
+    });
+}

package/dist/emitter.js

@@ -0,0 +1,19 @@
+import { TypedEmitter } from "./utils/TypedEmitter.js";
+export class Emitter {
+    emitter = new TypedEmitter();
+    emit(event) {
+        process.nextTick(() => this.emitter.emit("event", event));
+    }
+    connect(handler) {
+        this.emitter.on("event", handler);
+        return () => this.emitter.off("event", handler);
+    }
+    disconnect(handler) {
+        if (!handler) {
+            this.emitter.removeAllListeners();
+        }
+        else {
+            this.emitter.off("event", handler);
+        }
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export declare const foo = "foo";

package/dist/index.js

@@ -0,0 +1 @@
+export const foo = "foo";

package/dist/message.js

@@ -0,0 +1,18 @@
+import { v7 as uuid } from "uuid";
+export function isMessageType(type) {
+    return (message) => message.type === type;
+}
+export function message(type) {
+    return (message) => {
+        return { ...message, type, id: uuid() };
+    };
+}
+export function defineMessage(type) {
+    const factory = message(type);
+    const isMessage = isMessageType(type);
+    factory.is = isMessage;
+    factory.isMessage = isMessage;
+    factory.type = type;
+    factory.message = factory;
+    return factory;
+}

package/dist/message.test.js

@@ -0,0 +1,37 @@
+import { describe, expect, expectTypeOf, it } from "vitest";
+import { defineMessage } from "./message.js";
+describe("defineMessage", () => {
+    it("should create a message definition and type guard", () => {
+        const TestMessage = defineMessage("test.type");
+        const msg = TestMessage({ data: "test" });
+        expect(msg.type).toBe("test.type");
+        expect(TestMessage.type).toBe("test.type");
+        expect(TestMessage.is(msg)).toBe(true);
+    });
+    describe("is", () => {
+        it("should allow checking if a message is of the defined type", () => {
+            const TestMessage = defineMessage("test.type");
+            const OtherMessage = defineMessage("other.type");
+            const msg = TestMessage({ data: "test" });
+            expect(TestMessage.is(msg)).toBe(true);
+            expect(OtherMessage.is(msg)).toBe(false);
+            const unknownMsg = msg;
+            if (TestMessage.is(unknownMsg)) {
+                expectTypeOf(unknownMsg).toEqualTypeOf();
+            }
+            else {
+                expectTypeOf(unknownMsg).toEqualTypeOf();
+            }
+        });
+    });
+    describe("message", () => {
+        it("should provide a message builder function", () => {
+            const TestMessage = defineMessage("test.type");
+            const msg = TestMessage.message({ data: "test" });
+            expectTypeOf(msg).toEqualTypeOf();
+            expect(msg.type).toBe("test.type");
+            expect(msg.data).toBe("test");
+            expect(TestMessage.is(msg)).toBe(true);
+        });
+    });
+});

package/dist/server/memory.js

@@ -0,0 +1,46 @@
+import { Actor } from "../actor.js";
+import { defineMessage } from "../message.js";
+import { event, isConnect, isSend } from "./protocol.js";
+export const { message: localConnect, isMessage: isLocalConnect, type: LocalConnectType } = defineMessage("local-connect");
+export const { message: localRegister, isMessage: isLocalRegister, type: LocalRegisterType } = defineMessage("local-register");
+export class LocalServer extends Actor {
+    store = new Map();
+    send(command) {
+        if (isSend(command)) {
+            const { destination, message } = command;
+            const actor = this.store.get(destination);
+            if (actor) {
+                actor.send(message);
+            }
+        }
+        else if (isLocalConnect(command)) {
+            const { destination, callback } = command;
+            const actor = this.store.get(destination);
+            if (actor) {
+                actor.connect(callback);
+            }
+        }
+        else if (isLocalRegister(command)) {
+            const { name, actor } = command;
+            this.store.set(name, actor);
+        }
+    }
+}
+export class MemoryClient extends Actor {
+    server;
+    constructor(server) {
+        super();
+        this.server = server;
+    }
+    send(command) {
+        if (isSend(command)) {
+            this.server.send(command);
+        }
+        else if (isConnect(command)) {
+            this.server.send(localConnect({
+                destination: command.destination,
+                callback: (msg) => this.emit(event({ origin: command.destination, message: msg }))
+            }));
+        }
+    }
+}

package/dist/server/protocol.js

@@ -0,0 +1,4 @@
+import { defineMessage } from "../message.js";
+export const { message: send, isMessage: isSend, type: SendType } = defineMessage("send");
+export const { message: connect, isMessage: isConnect, type: ConnectType } = defineMessage("connect");
+export const { message: event, isMessage: isEvent, type: EventType } = defineMessage("event");

package/dist/server/websocket.js

@@ -0,0 +1,72 @@
+import { Actor } from "../actor.js";
+import { defineMessage } from "../message.js";
+export const { message: sendCommand, isMessage: isSendCommand, type: SendCommandType } = defineMessage("send-command");
+export const { message: openEvent, isMessage: isOpenEvent, type: OpenEventType } = defineMessage("open-event");
+export const { message: closeEvent, isMessage: isCloseEvent, type: CloseEventType } = defineMessage("close-event");
+export const { message: errorEvent, isMessage: isErrorEvent, type: ErrorEventType } = defineMessage("error-event");
+export const { message: messageEvent, isMessage: isMessageEvent, type: MessageEventType } = defineMessage("message-event");
+export class WebsocketClient extends Actor {
+    ws;
+    constructor(ws) {
+        super();
+        this.ws = ws;
+        ws.addEventListener("open", () => {
+            this.emit(openEvent({}));
+        });
+        ws.addEventListener("message", (event) => {
+            this.emit(messageEvent({ message: event.data }));
+        });
+        ws.addEventListener("close", () => {
+            this.emit(closeEvent({}));
+        });
+        ws.addEventListener("error", (event) => {
+            this.emit(errorEvent({ error: event }));
+        });
+    }
+    send(command) {
+        if (isSendCommand(command)) {
+            this.ws.send(command.message);
+        }
+    }
+}
+export class WebsocketClientWrapper extends Actor {
+    ws;
+    client;
+    constructor(ws) {
+        super();
+        this.ws = ws;
+        this.client = new WebsocketClient(ws);
+        this.client.connect((event) => {
+            if (isMessageEvent(event)) {
+                const message = JSON.parse(event.message);
+                this.emit(message);
+            }
+        });
+    }
+    send(command) {
+        this.client.send(sendCommand({ message: JSON.stringify(command) }));
+    }
+}
+export const { message: connectionEvent, isMessage: isConnectionEvent, type: ConnectionEventType } = defineMessage("connection-event");
+export class WebsocketServer extends Actor {
+    wss;
+    constructor(wss) {
+        super();
+        this.wss = wss;
+        this.wss.on("connection", (ws) => {
+            this.emit(connectionEvent({ ws }));
+        });
+    }
+}
+export class WebsocketServerWrapper {
+    constructor(ws, actor) {
+        //const client = new WebsocketClient(ws);
+        const wrapper = new WebsocketClientWrapper(ws);
+        wrapper.connect((command) => {
+            actor.send(command);
+        });
+        actor.connect((event) => {
+            wrapper.send(event);
+        });
+    }
+}

package/dist/server.js

@@ -0,0 +1,3 @@
+export * from "./server/protocol.js";
+export * from "./server/memory.js";
+export * from "./server/websocket.js";