@agent-glue/glue 0.1.2 → 0.1.3

package/.turbo/turbo-build.log

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

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

@@ -1 +1,5 @@
 
+
+> @agent-glue/glue@0.1.2 clean:build /home/gareth/Documents/Personal/2025/agent-glue/packages/agent-glue
+> rimraf ./dist
+

package/.turbo/turbo-lint.log

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

package/.turbo/turbo-typecheck.log

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

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @agent-glue/glue
 
+## 0.1.3
+
+### Patch Changes
+
+- Build issues
+
 ## 0.1.2
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-glue/glue",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "Glue is a simple actor model library for TypeScript",
   "author": "Gareth Andrew <gingerhendrix@gmail.com>",
   "license": "MIT",
@@ -58,8 +58,8 @@
     "ts-node": "^10.9.2",
     "vitest": "^3.0.4",
     "ws": "^8.18.0",
-    "@repo/eslint-config": "^0.0.0",
-    "@repo/typescript-config": "^0.0.0"
+    "@repo/typescript-config": "^0.0.0",
+    "@repo/eslint-config": "^0.0.0"
   },
   "scripts": {
     "build": "tsc",

package/dist/Actor.d.ts

@@ -1,51 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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/actors/examples/timer.d.ts

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

package/dist/actors/examples/timer.js

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

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

@@ -1,40 +0,0 @@
-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

@@ -1,52 +0,0 @@
-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

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

package/dist/index.d.ts

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

package/dist/index.js

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

package/dist/transformers.d.ts

@@ -1,41 +0,0 @@
-import { Message, ActorInterface } from "./Actor.js";
-export type Replace<U, A, B> = Exclude<U, A> | B;
-export type ActorTransformer<
-  A extends ActorInterface<C1, E1>,
-  B extends ActorInterface<C2, E2>,
-  C1 extends Message = never,
-  C2 extends Message = never,
-  E1 extends Message = never,
-  E2 extends Message = never
-> = (a: A) => B;
-export type CommandTransformer<
-  OldCommands extends Message,
-  NewCommands extends Message,
-  E extends Message = never,
-  A extends ActorInterface<OldCommands, E> = ActorInterface<OldCommands, E>,
-  B extends ActorInterface<NewCommands, E> = ActorInterface<NewCommands, E>
-> = ActorTransformer<A, B, OldCommands, NewCommands, E, E>;
-export type EventTransformer<
-  NewEvents extends Message,
-  OldEvents extends Message,
-  C extends Message = never,
-  A extends ActorInterface<C, OldEvents> = ActorInterface<C, OldEvents>,
-  B extends ActorInterface<C, NewEvents> = ActorInterface<C, NewEvents>
-> = ActorTransformer<A, B, C, C, OldEvents, NewEvents>;
-export type TransformerFunction<A extends Message, B extends Message> = (
-  message: A
-) => B;
-export declare function commandTransformer<
-  OldCommands extends Message,
-  NewCommands extends Message,
-  Events extends Message = never
->(
-  fn: TransformerFunction<NewCommands, OldCommands>
-): CommandTransformer<OldCommands, NewCommands, Events>;
-export declare function eventTransformer<
-  OldEvents extends Message,
-  NewEvents extends Message,
-  Commands extends Message = never
->(
-  fn: TransformerFunction<OldEvents, NewEvents>
-): EventTransformer<NewEvents, OldEvents, Commands>;

package/dist/utils/TypedEmitter.d.ts

@@ -1,15 +0,0 @@
-export declare class TypedEmitter<TEvents extends Record<string, unknown>> {
-  private emitter;
-  emit<TEventName extends keyof TEvents & string>(
-    eventName: TEventName,
-    eventArg: TEvents[TEventName]
-  ): void;
-  on<TEventName extends keyof TEvents & string>(
-    eventName: TEventName,
-    handler: (eventArg: TEvents[TEventName]) => void
-  ): void;
-  off<TEventName extends keyof TEvents & string>(
-    eventName: TEventName,
-    handler: (eventArg: TEvents[TEventName]) => void
-  ): void;
-}