@taskyon/tyclient 0.4.6 → 0.5.1

package/dist/tyclient.mjs

@@ -0,0 +1,735 @@
+import z3, { z } from 'zod';
+
+// ../taskyon/src/types/node.ts
+var JSONSchemaEnum = z.enum(["string", "number", "integer", "boolean", "object", "array", "null"]);
+var JSONSchema7 = z.lazy(() => JSONSchemaObjectRaw);
+var JSONSchema7Definition = z.lazy(
+  () => z.union([z.boolean(), JSONSchema7])
+);
+var JSONSchemaObjectRaw = z.strictObject({
+  $id: z.string().optional(),
+  $ref: z.string().optional(),
+  $schema: z.string().optional(),
+  $comment: z.string().optional(),
+  type: z.union([JSONSchemaEnum, z.array(JSONSchemaEnum)]).optional(),
+  const: z.any().optional(),
+  enum: z.any().optional(),
+  multipleOf: z.number().optional(),
+  maximum: z.number().optional(),
+  exclusiveMaximum: z.number().optional(),
+  minimum: z.number().optional(),
+  exclusiveMinimum: z.number().optional(),
+  maxLength: z.number().optional(),
+  minLength: z.number().optional(),
+  pattern: z.string().optional(),
+  items: z.lazy(() => z.union([JSONSchema7Definition, z.array(JSONSchema7Definition)]).optional()),
+  additionalItems: z.lazy(() => JSONSchema7Definition.optional()),
+  contains: z.lazy(() => JSONSchema7Definition.optional()),
+  maxItems: z.number().optional(),
+  minItems: z.number().optional(),
+  uniqueItems: z.boolean().optional(),
+  maxProperties: z.number().optional(),
+  minProperties: z.number().optional(),
+  required: z.array(z.string()).optional(),
+  properties: z.lazy(() => z.record(z.string(), JSONSchema7Definition).optional()),
+  patternProperties: z.lazy(() => z.record(z.string(), JSONSchema7Definition).optional()),
+  additionalProperties: z.lazy(() => JSONSchema7Definition.optional()),
+  unevaluatedProperties: z.lazy(() => JSONSchema7Definition.optional()),
+  dependencies: z.lazy(
+    () => z.record(z.string(), z.union([JSONSchema7Definition, z.array(z.string())])).optional()
+  ),
+  propertyNames: z.lazy(() => JSONSchema7Definition.optional()),
+  if: z.lazy(() => JSONSchema7Definition.optional()),
+  then: z.lazy(() => JSONSchema7Definition.optional()),
+  else: z.lazy(() => JSONSchema7Definition.optional()),
+  allOf: z.lazy(() => z.array(z.lazy(() => JSONSchema7Definition)).optional()),
+  anyOf: z.lazy(() => z.array(z.lazy(() => JSONSchema7Definition)).optional()),
+  oneOf: z.lazy(() => z.array(z.lazy(() => JSONSchema7Definition)).optional()),
+  not: z.lazy(() => JSONSchema7Definition.optional()),
+  format: z.string().optional(),
+  contentMediaType: z.string().optional(),
+  contentEncoding: z.string().optional(),
+  definitions: z.record(
+    z.string(),
+    z.lazy(() => JSONSchema7Definition)
+  ).optional(),
+  // support Draft‑2019+ $defs
+  // this is required, because the "json-schema-to-ts" library uses $defs and
+  // we can not validate those schemas without it.
+  $defs: z.record(
+    z.string(),
+    z.lazy(() => JSONSchema7Definition)
+  ).optional(),
+  title: z.string().optional(),
+  description: z.string().optional(),
+  default: z.any().optional(),
+  readOnly: z.boolean().optional(),
+  writeOnly: z.boolean().optional(),
+  examples: z.array(z.any()).optional(),
+  nullable: z.boolean().optional()
+});
+JSONSchemaObjectRaw.extend({
+  $id: z.string()
+});
+
+// ../taskyon/src/types/tools.ts
+var taskMarker = "*TY_TASKRESULT*";
+var FunctionName = z3.string().refine((val) => /^[a-zA-Z0-9_-]+$/.test(val), {
+  error: ({ input }) => {
+    const msg = typeof input === "string" ? input : JSON.stringify(input);
+    return `The function/tool name ${msg} contains illegal characters. It has to fulfill '^[a-zA-Z0-9_-]+$'`;
+  }
+});
+var ParamType = z3.union([
+  z3.string(),
+  z3.number(),
+  z3.boolean(),
+  z3.record(z3.string(), z3.unknown()),
+  z3.array(z3.unknown()),
+  z3.null(),
+  // We are also allowing undefined calls to the functions, even though this is not allowed in jsonschema.
+  // But we are sometimes calling our functions manually and this way we can also call them without parameters.
+  z3.undefined()
+]);
+var FunctionArguments = z3.record(z3.string(), ParamType).meta({
+  description: "arguments of the function"
+});
+var FunctionCall = z3.object({
+  name: FunctionName,
+  arguments: FunctionArguments
+});
+var ToolBase = z3.object({
+  description: z3.string().meta({
+    description: "A short description about the tool so that an LLM knows when to use it."
+  }),
+  longDescription: z3.string().optional().meta({
+    description: "An optional longer description for more complicated operations with this tool."
+  }),
+  name: FunctionName.meta({
+    description: "Name of the tool. Has to fulfill: /^[a-zA-Z0-9_-]+$/"
+  }),
+  renderOptions: z3.object({
+    hideChat: z3.boolean().describe(
+      "hide the tool in the UI chat. Useful if the function is used very often and we don't want it to clutter the chatWindow"
+    ),
+    hideLlm: z3.boolean(
+      `HideLlm will hide the  tool from an LLM inside chatCompletion. This is mainly useful for tools like "chatCompletion" which the llm doesn't need to see in the chatCompletion.`
+    )
+  }).partial().optional(),
+  parameters: JSONSchema7.meta({
+    description: "A JSON schema object describing the parameters of the function."
+  }).readonly(),
+  code: z3.string().optional().describe(
+    `The functionality of the tool as javascript code. If a function description doesn't include any code,
+Taskyon will automatically call a postMessage event with the parameters to the parent window
+with the function name.`
+  )
+});
+
+// ../taskyon/src/types/node.ts
+var Annotation = z3.union([
+  z3.object({
+    type: z3.literal("url_citation"),
+    url_citation: z3.object({
+      end_index: z3.number(),
+      start_index: z3.number(),
+      title: z3.string(),
+      url: z3.string(),
+      content: z3.string()
+    }).partial().optional()
+  }),
+  z3.object({
+    type: z3.literal("file"),
+    content: z3.object({
+      text: z3.string(),
+      type: z3.string()
+    }).array().optional()
+  })
+]);
+var MessageContent = z3.object({
+  type: z3.literal("message"),
+  data: z3.string(),
+  ann: Annotation.array().optional()
+});
+var StructuredContent = z3.object({
+  type: z3.literal("structured"),
+  data: z3.unknown()
+});
+var ToolCallContent = z3.object({ type: z3.literal("functioncall"), data: FunctionCall });
+var UploadedFilesContent = z3.object({
+  type: z3.literal("files"),
+  data: z3.array(z3.string())
+});
+var ToolResultContent = z3.object({ type: z3.literal("toolresult"), data: z3.unknown() });
+var ToolDefinition = z3.object({ type: z3.literal("tooldefinition"), data: ToolBase });
+var ErrorContent = z3.object({ type: z3.literal("error"), data: z3.unknown() }).meta({
+  description: "Gets created if any error occurs during task processing."
+});
+var Return = z3.object({ type: z3.literal("return"), data: z3.string() }).describe(
+  `A Termination task always indicates the end of an autonomous task chat execution.
+Every Leaf task which is not a Termination task can potentially continue to be executed...
+
+We can indicate the reason for termination here as well...`
+);
+z3.union([MessageContent, ToolResultContent, ErrorContent]);
+var TaskContent = z3.union([
+  MessageContent.strict(),
+  ToolResultContent.strict(),
+  ToolDefinition.strict(),
+  ErrorContent.strict(),
+  StructuredContent.strict(),
+  ToolCallContent.strict(),
+  // TODO: replace with a "context" function which can also be a link to a URL for example or maybe a search string for other tasks...
+  //       we can declare function for a lot of these things this way :)
+  UploadedFilesContent.strict(),
+  Return.strict()
+]);
+var TaskNode = z3.object({
+  // TODO: get rid of "role"  and put it into chatCompletion only...
+  // we don't need it in the rest of the app, I think.. we might be able to indicate that a task was
+  // "automatically" created by using a notation in "authorID" e.g. something like.
+  // "pubKey:gen" if the task was automatically generated && pubKey if it wasn't
+  // OR: we could simply check the parents & priors of tasks. if tasks have a parent, they were generated
+  // by a function. user-generated message should not have a parent...
+  role: z3.enum(["system", "user", "assistant", "function"]),
+  name: z3.string().optional().meta({
+    description: "An optional name for the task"
+  }),
+  content: TaskContent.describe(
+    `This is the actual content of the task. This is the actual content which is process at each step.
+For example this is, what an LLM would actually get to see. There are only a few different ways
+of how content can be structured. `
+  ),
+  label: z3.array(z3.string()).optional(),
+  parentID: z3.string().optional().meta({
+    description: "The ID of the parent task which created this subtask on a lower stack level"
+  }),
+  priorID: z3.string().optional().meta({
+    description: "The ID of the previous task in the same stack level."
+  }),
+  // TODO: validate this ID using our content address creation functions
+  id: z3.string(),
+  authorId: z3.string().optional(),
+  created_at: z3.number().optional(),
+  acl: z3.string().array().optional().describe(`A number of public keys which act as access control lists (ACL).
+They are given certain as a list of public keys + type of ownership.
+ ["pubkey:owner", "pubkey:editor1", "pubkey:editor2"]
+
+ The value is optional. If no ACL is specified, the task is "public" and
+ can for example be freely exchange in p2p settings.
+
+TODO: define onwership types..`),
+  sig: z3.string().optional().meta({
+    description: "A signature from the author of the Task. It is created from the entire content of the tasj except for the signature itself."
+  })
+});
+var partialTaskDraft = TaskNode.partial().required({ role: true, content: true }).meta({
+  description: "This is just a subset of the task properties which can be used to define new tasks in various places."
+});
+TaskContent.options.map((opt) => {
+  return opt.shape.type._zod.def.values[0];
+});
+z3.enum(["Open", "Queued", "In Progress", "Completed", "Cancelled", "Error"]).describe(`The task state indicates on what is happening with the task: for example
+it shows whether a task flow is seen as "completed" or whether its waiting
+to be further processed... E.g. there could be a task with no results, which stil counts as "completed"`);
+
+// ../taskyon/src/utils/encoding.ts
+function uint8ArrayToBase64UrlSafe(data) {
+  const u8 = data instanceof Uint8Array ? data : new Uint8Array(data);
+  let binary = "";
+  for (let i = 0; i < u8.length; i++) {
+    binary += String.fromCharCode(u8[i]);
+  }
+  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+async function sha256UrlSafeHash(obj) {
+  const json = JSON.stringify(obj);
+  const encoder = new TextEncoder();
+  const data = encoder.encode(json);
+  const hashBuffer = await crypto.subtle.digest("SHA-256", data);
+  return uint8ArrayToBase64UrlSafe(hashBuffer);
+}
+async function sha256UrlSafeHashFromFile(file) {
+  const buffer = await file.arrayBuffer();
+  const hashBuffer = await crypto.subtle.digest("SHA-256", buffer);
+  return uint8ArrayToBase64UrlSafe(hashBuffer);
+}
+
+// ../taskyon/src/core/createTasks.ts
+var TaskWithoutId = TaskNode.omit({ id: true }).strip();
+function normalizeObj(task) {
+  const clone = JSON.parse(JSON.stringify(task));
+  const sorted = Object.keys(clone).sort().reduce((acc, key) => {
+    acc[key] = clone[key];
+    return acc;
+  }, {});
+  return sorted;
+}
+async function taskContentHash(task) {
+  if (typeof crypto === "undefined" || !crypto.subtle) {
+    throw new Error(
+      "crypto.subtle is not available in this environment, We can currently not generate task IDs!!"
+    );
+  }
+  console.log("generating new hash ID for task");
+  const taskWithoutId = TaskWithoutId.parse(task);
+  const normalized = normalizeObj(taskWithoutId);
+  const hash = await sha256UrlSafeHash(normalized);
+  return { hash, normalized };
+}
+async function ensureValidTaskId(task) {
+  const { hash, normalized } = await taskContentHash(task);
+  if (task.id && hash !== task.id) {
+    throw new Error(
+      `Not able to create new task as id doesn't match content. Expected: ${hash} got: ${task.id}.`
+    );
+  }
+  return { ...normalized, id: hash };
+}
+var forgeTaskChain = async (tasks) => {
+  const flattened = [];
+  for (const tl of tasks) {
+    let lastTaskId = void 0;
+    for (const t of tl) {
+      const task = await createTaskNode({ ...t, priorID: lastTaskId }, { createMeta: "missing" });
+      lastTaskId = task.id;
+      flattened.push(task);
+    }
+  }
+  return flattened;
+};
+function addTaskNodeMeta(options, task) {
+  const next = { ...task };
+  if (options.createMeta === "overwrite") {
+    next.created_at = Date.now();
+  }
+  if (options.createMeta !== void 0 && !next.created_at) {
+    next.created_at = Date.now();
+  }
+  return next;
+}
+var createTaskNode = async (task, options = { createMeta: "missing" }) => {
+  if (!task.id) {
+    const newTask = addTaskNodeMeta(options, task);
+    return ensureValidTaskId(newTask);
+  }
+  return ensureValidTaskId(task);
+};
+var internalToolFunctionSchema = z3.custom((val) => typeof val === "function", {
+  message: "Expected a function that accepts any arguments and returns unknown or Promise<unknown>"
+});
+ToolBase.extend({
+  // TODO: take away he "optional" from this type here...
+  function: internalToolFunctionSchema.optional()
+}).meta({
+  description: "Internal tool definition, which has access to the taskyon system"
+});
+function createTool(tool) {
+  console.log("create tool", tool.name);
+  return tool;
+}
+function toolCall(f) {
+  return {
+    role: "function",
+    content: {
+      type: "functioncall",
+      data: f
+    }
+  };
+}
+z3.object({
+  taskResultMarker: z3.literal(taskMarker).default(taskMarker).meta({
+    description: "we use this marker in order to indicate that the result should be added as new tasks!"
+  }),
+  taskChainList: z3.array(z3.array(partialTaskDraft))
+});
+function makeTaskResult(tasks) {
+  let tasksArray;
+  if (Array.isArray(tasks)) {
+    if (Array.isArray(tasks[0])) {
+      tasksArray = tasks;
+    } else {
+      tasksArray = [tasks];
+    }
+  } else {
+    tasksArray = [[tasks]];
+  }
+  tasks = tasksArray;
+  return {
+    taskResultMarker: taskMarker,
+    taskChainList: tasks
+  };
+}
+var RemoteFunctionBase = z3.object({
+  functionName: z3.string().meta({
+    description: "the name of the function"
+  })
+});
+var RemoteFunctionCall = RemoteFunctionBase.extend({
+  type: z3.literal("functionCall").meta({
+    description: "Field to indicate what kind of a message we have here."
+  }),
+  arguments: FunctionArguments.optional().meta({
+    description: "the arguments for the function as a json object"
+  })
+}).meta({
+  description: "This type is used for sending messages with function calls between windows. E.g. from iframe to parent"
+});
+var RemoteFunctionResponse = RemoteFunctionBase.extend({
+  type: z3.literal("functionResponse").meta({
+    description: "Field to indicate what kind of a message we have here."
+  }),
+  response: z3.unknown().optional().meta({
+    description: "response of a FunctionCall, e.g. through postMessage with iframes."
+  }),
+  error: z3.unknown().optional().meta({ description: "if an error occurs in the remote function, we can use this property" })
+}).meta({
+  description: "This type is used for sending messages with the result of a remote function call between windows. E.g. from parent to taskyon iframe"
+});
+
+// ../taskyon/src/types/apiTypes.ts
+var EncryptedTasks = z.object({
+  type: z.literal("addTasks"),
+  data: z.instanceof(Uint8Array),
+  info: z.string(),
+  ids: z.array(z.string())
+});
+var RequestTask = z.object({
+  type: z.literal("requestTask"),
+  id: z.string()
+});
+var TaskCreated = z.object({
+  type: z.literal("taskCreated"),
+  task: TaskNode.optional(),
+  // TODO: add optional encrypted task!
+  ids: z.array(z.string()).optional(),
+  info: z.string().optional()
+});
+var TaskMessage = z.object({
+  type: z.literal("task").meta({
+    description: "Field to indicate what kind of a message we have here."
+  }),
+  task: partialTaskDraft,
+  // TODO: we don't need this anymore..   any functioncall task is one that should be "executed"
+  execute: z.boolean().default(false).meta({
+    description: "should the task be queued for execution?"
+  }),
+  /* TODO: this needs to be captured in the frontend somehow!
+  // but we first add it to the tasks and get back a content ID in the backend.
+  // so not sure yet how to do this...The backend soehow would have to communicate this to the frontend..
+  // maybe we could do this through teh "back-channel?"*/
+  show: z.boolean().default(false).meta({
+    description: "select the task in the GUI"
+  })
+}).meta({
+  description: "With this message type we can send tasks to taskyon from outside, e.g. a parent to a taskyon iframe"
+});
+var TaskChainMessage = z.object({
+  type: z.literal("tasks").meta({
+    description: "Field to indicate what kind of a message we have here."
+  }),
+  execute: z.boolean().default(false),
+  tasks: partialTaskDraft.array(),
+  show: z.boolean().default(false).meta({
+    description: "select the last task in the GUI"
+  })
+});
+var FunctionDescriptionMessage = ToolBase.extend({
+  type: z.literal("functionDescription").meta({
+    description: "Field to indicate that this is a function description message."
+  })
+});
+var TyReadyMessage = z.object({ type: z.literal("taskyonReady") }).meta({
+  description: "simple message which signals, that our API is ready!"
+});
+var BaseMessage = z.object({
+  origin: z.string().optional(),
+  peerId: z.string().optional()
+});
+var TyStatusMessage = z.object({
+  type: z.literal("status"),
+  data: z.object({
+    type: z.literal("newtool"),
+    id: z.string().meta({ description: "id of new tool" })
+  })
+}).meta({ description: "A list of status message for taskyon" });
+var TaskWorkerMessage = z.discriminatedUnion("type", [
+  z.object({ ...BaseMessage.shape, ...RemoteFunctionCall.shape }),
+  z.object({ ...BaseMessage.shape, ...RemoteFunctionResponse.shape })
+]);
+var FileMessage = z.object({
+  type: z.literal("file"),
+  id: z.string(),
+  name: z.string(),
+  mime: z.string(),
+  size: z.number(),
+  store: z.enum(["memory", "opfs"]).optional(),
+  file: z.file()
+  // only supported over MessageChannel for now
+});
+var TyP2P = z.discriminatedUnion("type", [EncryptedTasks, RequestTask, TaskCreated]);
+var TyBusMessage = z.discriminatedUnion("type", [
+  ...TyP2P.options,
+  z.object({ ...BaseMessage.shape, ...TyStatusMessage.shape }),
+  ...TaskWorkerMessage.options
+]);
+z.discriminatedUnion("type", [
+  // TODO: can we unify the task message with the SyncApi?
+  ...TyBusMessage.options,
+  z.object({ ...BaseMessage.shape, ...TaskMessage.shape }),
+  z.object({ ...BaseMessage.shape, ...TaskChainMessage.shape }),
+  z.object({ ...BaseMessage.shape, ...FunctionDescriptionMessage.shape }),
+  z.object({ ...BaseMessage.shape, ...TyReadyMessage.shape }),
+  z.object({ ...BaseMessage.shape, ...FileMessage.shape })
+]);
+var sendFile = (send) => async (file) => {
+  const id = await sha256UrlSafeHashFromFile(file);
+  send({
+    type: "file",
+    id,
+    name: file.name,
+    mime: file.type,
+    size: file.size,
+    file
+  });
+  return id;
+};
+
+// ../taskyon/src/utils/frpBus.ts
+function createStream() {
+  const observers = [];
+  const stream = (observer) => {
+    observers.push(observer);
+    return () => {
+      const idx = observers.indexOf(observer);
+      if (idx >= 0) observers.splice(idx, 1);
+    };
+  };
+  stream.unsubscribeAll = () => {
+    observers.length = 0;
+  };
+  stream.narrow = (pred) => {
+    const newStream = createStream();
+    stream((v) => {
+      if (pred(v)) newStream.emit(v);
+    });
+    return newStream.stream;
+  };
+  stream.map = (fn) => {
+    const newStream = createStream();
+    stream((v) => newStream.emit(fn(v)));
+    return newStream.stream;
+  };
+  stream.filter = stream.narrow;
+  stream.wait = (opts) => new Promise((resolve, reject) => {
+    if (opts?.signal?.aborted) {
+      const err = new Error("Aborted");
+      err.name = "AbortError";
+      reject(err);
+      return;
+    }
+    let done = false;
+    let timeout;
+    let unsub = () => {
+    };
+    const finish = (err, value) => {
+      if (done) return;
+      done = true;
+      unsub();
+      clearTimeout(timeout);
+      opts?.signal?.removeEventListener("abort", onAbort);
+      if (err) reject(err);
+      else resolve(value);
+    };
+    const onAbort = () => {
+      const err = new Error("Aborted");
+      err.name = "AbortError";
+      finish(err);
+    };
+    opts?.signal?.addEventListener("abort", onAbort);
+    if (opts?.timeoutMs)
+      timeout = setTimeout(
+        () => finish(new Error(`Timeout after ${opts.timeoutMs}ms`)),
+        opts.timeoutMs
+      );
+    const observer = (value) => finish(void 0, value);
+    unsub = stream(observer);
+  });
+  return {
+    stream,
+    emit: (v) => {
+      [...observers].forEach((o) => void o(v));
+    }
+  };
+}
+var connectChannels = (x, y) => {
+  const unsubX = x.receive((msg) => y.send(msg));
+  const unsubY = y.receive((msg) => x.send(msg));
+  return () => {
+    unsubX();
+    unsubY();
+  };
+};
+var makePort = (send, receive) => {
+  const self = {
+    send,
+    receive,
+    connect: (other) => connectChannels(self, other)
+  };
+  return self;
+};
+var createChannelsFromStreams = (outS, inS) => ({
+  x: makePort(outS.emit, inS.stream),
+  y: makePort(inS.emit, outS.stream)
+});
+var createDuplexChannel = () => createChannelsFromStreams(createStream(), createStream());
+function MessageChannelBridge(dport, mport) {
+  const unsub = dport.receive((msg) => mport.postMessage(msg));
+  mport.onmessage = (msg) => dport.send(msg.data);
+  const destroy = () => {
+    unsub();
+    mport.close();
+  };
+  return { destroy };
+}
+
+// ../taskyon/src/api/index.ts
+var createChatCompletionTask = (args) => toolCall({ name: "chatCompletion", arguments: args });
+var processTasks = (tyPort) => async (taskList, opts) => {
+  const tasks = await forgeTaskChain(taskList);
+  tyPort.send({
+    type: "tasks",
+    tasks,
+    execute: true,
+    show: true,
+    // we want to show this task in our GUI as a succesful test
+    origin: "Taskyon Diagnostics"
+  });
+  const initialIds = tasks.map((t) => t.id);
+  const subTasks = new Set(initialIds);
+  const subTasksCreated = tyPort.receive.narrow((m) => {
+    console.log("api received", m);
+    if (m.type === "taskCreated" && "task" in m && !!m.task?.id && !!m.task?.parentID && subTasks.has(m.task?.parentID)) {
+      subTasks.add(m.task?.id);
+      return true;
+    }
+    return false;
+  }).map((msg) => msg.task);
+  const condition = opts.quitCondition ? subTasksCreated.filter(opts.quitCondition) : subTasksCreated.filter((t) => t.content.type === "message");
+  const unsub = condition((m) => console.log("received matching message on port:", m));
+  const lastMsg = await condition.wait(opts);
+  console.log("finished processin all tasks!");
+  unsub();
+  return lastMsg;
+};
+
+// src/index.ts
+function safeClone(data) {
+  try {
+    return structuredClone(data);
+  } catch {
+    return JSON.parse(JSON.stringify(data));
+  }
+}
+var waitForApiChannel = (iframe) => {
+  return new Promise((resolve) => {
+    let stopped = false;
+    const tryConnect = () => {
+      if (stopped) return;
+      const channel = new MessageChannel();
+      const targetOrigin = new URL(iframe.src, location.href).origin || "*";
+      const handleFirst = (ev) => {
+        console.log("tyclient received first message from taskyon!", ev);
+        stopped = true;
+        channel.port1.removeEventListener("message", handleFirst);
+        clearTimeout(retryTimer);
+        resolve(channel.port1);
+      };
+      channel.port1.addEventListener("message", handleFirst, { once: true });
+      channel.port1.start();
+      try {
+        iframe.contentWindow?.postMessage({ type: "initPort" }, targetOrigin, [channel.port2]);
+      } catch {
+      }
+      const retryTimer = setTimeout(() => {
+        if (!stopped) {
+          channel.port1.close();
+          channel.port2.close();
+          tryConnect();
+        }
+      }, 200);
+    };
+    tryConnect();
+  });
+};
+async function handleFunctionExecution(args, tool, stopSignal) {
+  const result = await tool.function(args, {
+    taskChain: [],
+    getSecret: (name) => {
+      console.log("tyclient get secret name", name);
+      return Promise.resolve("N/A");
+    },
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    setSecret: (name, _value) => {
+      console.log("tyclient set secret name", name);
+      return Promise.resolve();
+    },
+    stopSignal,
+    toolId: "N/A"
+  });
+  return result;
+}
+async function initializeTaskyon(options) {
+  console.log("initialize taskyon tyclient...");
+  const toolMap = options.tools.reduce((p, c) => {
+    p[c.name] = c;
+    return p;
+  }, {});
+  const taskyon = document.getElementById("taskyon");
+  const controller = new AbortController();
+  const { x: clientSidePort, y: towardsIframe } = createDuplexChannel();
+  if (taskyon !== null && taskyon.tagName === "IFRAME" && taskyon.contentWindow !== null) {
+    console.log("make sure, we can ");
+    const iframeMessagePort = await waitForApiChannel(taskyon);
+    MessageChannelBridge(towardsIframe, iframeMessagePort);
+    const send = (msg) => {
+      console.log("tyclient sending", msg);
+      clientSidePort.send(safeClone(msg));
+    };
+    console.log("tyclient send our configuration!");
+    send({
+      type: "configurationMessage",
+      conf: options.configuration,
+      persist: options.persist,
+      origin: window.location.origin,
+      peerId: options?.name
+    });
+    console.log("tyclient sending our functions!");
+    options.tools.forEach((t) => {
+      const { function: _toolfunc, ...fdescr } = t;
+      send({
+        type: "functionDescription",
+        ...fdescr
+      });
+    });
+    console.log("tyclient set up function listener!");
+    clientSidePort.receive((msg) => console.log("tyclient received message", msg));
+    clientSidePort.receive.narrow((msg) => msg.type === "functionCall")(async (msg) => {
+      const tool = toolMap[msg.functionName];
+      if (tool) {
+        const res = await handleFunctionExecution(msg.arguments ?? {}, tool, controller.signal);
+        send({ type: "functionResponse", functionName: tool.name, response: res });
+        console.log("tyclient tool send functionResponse to iframe", res, tool);
+      }
+    });
+  }
+  return {
+    processTasks: processTasks(clientSidePort),
+    port: clientSidePort,
+    sendFile: (file) => sendFile(clientSidePort.send)(file)
+  };
+}
+
+export { createChatCompletionTask, createTool, initializeTaskyon, makeTaskResult, processTasks, toolCall };
+//# sourceMappingURL=tyclient.mjs.map
+//# sourceMappingURL=tyclient.mjs.map