@band-ai/sdk 0.1.2

package/dist/chunk-AVVDPXP4.js

@@ -0,0 +1,39 @@
+// src/core/simpleAdapter.ts
+var SimpleAdapter = class {
+  historyConverter;
+  agentName = "";
+  agentDescription = "";
+  constructor(options) {
+    this.historyConverter = options?.historyConverter;
+  }
+  async onCleanup(_roomId) {
+  }
+  async onStarted(agentName, agentDescription) {
+    this.agentName = agentName;
+    this.agentDescription = agentDescription;
+  }
+  async onEvent(input) {
+    const history = this.convertHistory(input.history);
+    await this.onMessage(
+      input.message,
+      input.tools,
+      history,
+      input.participantsMessage,
+      input.contactsMessage,
+      {
+        isSessionBootstrap: input.isSessionBootstrap,
+        roomId: input.roomId
+      }
+    );
+  }
+  convertHistory(provider) {
+    if (!this.historyConverter) {
+      return provider;
+    }
+    return provider.convert(this.historyConverter);
+  }
+};
+
+export {
+  SimpleAdapter
+};

package/dist/chunk-EDPKUUJL.js

@@ -0,0 +1,177 @@
+import {
+  BASE_TOOL_NAMES,
+  CONTACT_TOOL_NAMES,
+  MEMORY_TOOL_NAMES,
+  TOOL_MODELS,
+  getToolDescription
+} from "./chunk-GVEQ3RAH.js";
+import {
+  isToolExecutorError,
+  toLegacyToolExecutorErrorMessage
+} from "./chunk-3BKAC4OZ.js";
+
+// src/mcp/registrations.ts
+function buildRoomScopedRegistrations(resolver, options = {}) {
+  const toolNames = resolveToolNames(options);
+  const registrations = buildRegistrations(toolNames, async (toolName, args) => {
+    const roomId = asNonEmptyString(args.room_id);
+    if (!roomId) {
+      return errorResult("Missing required room_id");
+    }
+    const tools = resolver(roomId);
+    if (!tools) {
+      return errorResult(`No tool context found for room_id ${roomId}`);
+    }
+    const toolArgs = { ...args };
+    delete toolArgs.room_id;
+    return executeToolCall(tools, toolName, toolArgs);
+  }, { injectRoomId: true });
+  if (options.additionalTools) {
+    registrations.push(...options.additionalTools);
+  }
+  return registrations;
+}
+function buildSingleContextRegistrations(tools, options = {}) {
+  const toolNames = resolveToolNames(options);
+  const registrations = buildRegistrations(toolNames, (_toolName, args) => {
+    return executeToolCall(tools, _toolName, args);
+  }, { injectRoomId: false });
+  if (options.additionalTools) {
+    registrations.push(...options.additionalTools);
+  }
+  return registrations;
+}
+function resolveToolNames(options) {
+  const names = /* @__PURE__ */ new Set();
+  for (const name of BASE_TOOL_NAMES) {
+    if (!options.enableContactTools && CONTACT_TOOL_NAMES.has(name)) {
+      continue;
+    }
+    names.add(name);
+  }
+  if (options.enableMemoryTools) {
+    for (const name of MEMORY_TOOL_NAMES) {
+      names.add(name);
+    }
+  }
+  return names;
+}
+function buildRegistrations(toolNames, executor, opts) {
+  const registrations = [];
+  for (const toolName of toolNames) {
+    const model = TOOL_MODELS[toolName];
+    if (!model) {
+      continue;
+    }
+    const properties = { ...model.properties };
+    const required = [...model.required];
+    if (opts.injectRoomId) {
+      properties.room_id = { type: "string", description: "The room ID to execute this tool in" };
+      required.push("room_id");
+    }
+    registrations.push({
+      name: toolName,
+      description: getToolDescription(toolName),
+      inputSchema: {
+        type: "object",
+        properties,
+        required
+      },
+      execute: (args) => executor(toolName, args)
+    });
+  }
+  return registrations;
+}
+async function executeToolCall(tools, toolName, args) {
+  try {
+    const result = await tools.executeToolCall(toolName, args);
+    if (isToolExecutorError(result)) {
+      return errorResult(toLegacyToolExecutorErrorMessage(result) ?? result.message);
+    }
+    return successResult(result);
+  } catch (error) {
+    return errorResult(error instanceof Error ? error.message : String(error));
+  }
+}
+function asNonEmptyString(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function successResult(value) {
+  return {
+    content: [{
+      type: "text",
+      text: serializeValue(value)
+    }]
+  };
+}
+function errorResult(message) {
+  return {
+    content: [{ type: "text", text: message }],
+    isError: true
+  };
+}
+function serializeValue(value) {
+  if (value === void 0 || value === null) {
+    return "";
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  try {
+    const json = JSON.stringify(value);
+    return typeof json === "string" ? json : String(value);
+  } catch {
+    return String(value);
+  }
+}
+
+// src/mcp/zod.ts
+function buildZodShape(z, properties, required) {
+  const shape = {};
+  for (const [name, schema] of Object.entries(properties)) {
+    const validator = jsonSchemaToZod(z, schema);
+    shape[name] = required.has(name) ? validator : validator.optional();
+  }
+  return shape;
+}
+function jsonSchemaToZod(z, schema) {
+  const type = schema.type;
+  if (type === "string") {
+    if (Array.isArray(schema.enum) && schema.enum.every((v) => typeof v === "string")) {
+      const values = schema.enum;
+      if (values.length > 0) {
+        return z.enum(values);
+      }
+    }
+    return z.string();
+  }
+  if (type === "integer" || type === "number") {
+    return z.number();
+  }
+  if (type === "boolean") {
+    return z.boolean();
+  }
+  if (type === "array") {
+    const itemSchema = schema.items;
+    if (itemSchema && typeof itemSchema === "object") {
+      return z.array(jsonSchemaToZod(z, itemSchema));
+    }
+    return z.array(z.unknown());
+  }
+  if (type === "object") {
+    return z.record(z.string(), z.unknown());
+  }
+  return z.unknown();
+}
+
+export {
+  buildRoomScopedRegistrations,
+  buildSingleContextRegistrations,
+  successResult,
+  errorResult,
+  buildZodShape
+};