Unsure how to use unsafeType within defineNodeType

[Mearman]

When trying to use the examples from the readme, it still only allows the primitives, so I get: "Type '"object"' is not assignable to type '"string" | "number" | "boolean"".
Is there a step I'm missing? It would be useful to see a sample of how to use unsafeType or in general a non-primitive with defineNodeType.

breadboard/packages/build/README.md

Lines 101 to 109 in a20538f

	const myCrazyType = unsafeType<{ foo: string }>({
	type: "object",
	properties: {
	foo: {
	type: "string",
	},
	},
	required: ["foo"],
	});

this is a (currently invalid) sample of what I was attempting. without the unsafeType for clarity

export const entries = defineNodeType({
  inputs: {
    object: {
      type: "object",
      description: "The object to get entries from",
    },
  },
  outputs: {
    entries: {
      type: "array",
      description: "The entries of the object",
      primary: true,
    },
  },
  invoke: ({ object }) => {
    return {
      entries: Object.entries(object),
    };
  },
});

[Mearman]

• see [build] Add object utility to type system #1197

[aomarks]

When trying to use the examples from the readme, it still only allows the primitives, so I get: "Type '"object"' is not assignable to type '"string" | "number" | "boolean"".

I think you just need to sync with main to pull in #1196. Among other things, that PR expanded unsafeType to allow taking any valid JSON Schema, whereas previously it was a small subset.

[Mearman]

@aomarks I might need pointing in the right direction in terms of how to handle an object or array of unknowns.
here's an example.
how would the inputs and outputs be written for defineNodeType with this function:

async function invokePop<T>({ array }: { array: T[] }): Promise<{
  item: T | undefined;
  array: T[];
}> {
  const item = array.pop();
  return {
    item,
    array,
  };
}

[aomarks]

I just added "unknown" in #1200, so you should now be able to do something like:

import { defineNodeType, array } from "@breadboard-ai/build";

export const pop = defineNodeType({
  inputs: {
    arr: {
      type: array("unknown"),
    },
  },
  outputs: {
    last: {
      type: "unknown"
    },
  },
  invoke: ({ arr }) => ({
    last: arr.pop(),
  }),
});

This isn't going to carry the generic information, but that should be fine for now and and I'll have a think about how we can express it in a way that does carry the generic.

[Mearman]

superb. I shall experiment.
I was also pondering about the concept of generics in BGL. I think it'd certainly be useful in cases like the boards that require a predicate.

[Mearman]

we edge closer.
to export, I need to type the const. though I can't figure out the correct config for the MonomorphicDefinition generics.
scratch that. I think I've got it

export const popNodeType: MonomorphicDefinition<
  {
    array: {
      type: AdvancedBreadboardType<unknown[]>;
    };
  },
  {
    last: {
      type: "unknown";
    };
    array: {
      type: AdvancedBreadboardType<unknown[]>;
    };
  }
> = defineNodeType({
  inputs: {
    array: {
      type: array("unknown"),
    },
  },
  outputs: {
    last: {
      type: "unknown",
    },
    array: {
      type: array("unknown"),
    },
  },
  invoke: <T>(inputs: { array: T[] }): { last: T | undefined; array: T[] } => {
    const { array } = inputs;
    const last = array.pop();
    return {
      last,
      array,
    };
  },
});

[Mearman]

Leaving these here for reference

export const popNodeType = defineNodeType({
  inputs: {
    array: {
      type: array("unknown"),
    },
  },
  outputs: {
    last: {
      type: "unknown",
    },
    array: {
      type: array("unknown"),
    },
  },
  invoke: <T>(inputs: { array: T[] }): { last: T | undefined; array: T[] } => {
    const { array } = inputs;
    const last = array.pop();
    return {
      last,
      array,
    };
  },
});

const popNodeHandler: NodeHandler = {
  invoke: <T>({
    array,
  }: {
    array: T[];
  }): Promise<{ last: T | undefined; array: T[] }> => {
    const last = array.pop();
    return Promise.resolve({
      last,
      array,
    });
  },
};